@types/core-js

Version 2.5.8
Published 1 year ago
87.9 kB
No dependencies
MIT license

Install

npm i @types/core-js

yarn add @types/core-js

pnpm add @types/core-js

Overview

TypeScript definitions for core-js

Index

Variables

variable Dict

var Dict: DictConstructor;

Non-standard.

Functions

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function delay

delay: (msec: number) => Promise<void>;

Namespaces

namespace core

namespace core {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js

module 'core-js' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js.Reflect

namespace core-js.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/core

module 'core-js/core' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/core.Reflect

namespace core-js/core.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/core/_

module 'core-js/core/_' {}

namespace core-js/core/$for

module 'core-js/core/$for' {}

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

namespace core-js/core/array

module 'core-js/core/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/core/date

module 'core-js/core/date' {}

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

namespace core-js/core/delay

module 'core-js/core/delay' {}

variable delay

const delay: (msec: number) => Promise<void>;

namespace core-js/core/dict

module 'core-js/core/dict' {}

variable Dict

const Dict: DictConstructor;

namespace core-js/core/function

module 'core-js/core/function' {}

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

namespace core-js/core/global

module 'core-js/core/global' {}

variable global

const global: any;

namespace core-js/core/number

module 'core-js/core/number' {}

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

namespace core-js/core/object

module 'core-js/core/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/core/string

module 'core-js/core/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/es5

module 'core-js/es5' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/es5.Reflect

namespace core-js/es5.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/es6

module 'core-js/es6' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/es6.Reflect

namespace core-js/es6.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/es6/array

module 'core-js/es6/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/es6/function

module 'core-js/es6/function' {}

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

namespace core-js/es6/map

module 'core-js/es6/map' {}

variable Map

const Map: MapConstructor;

namespace core-js/es6/math

module 'core-js/es6/math' {}

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

namespace core-js/es6/number

module 'core-js/es6/number' {}

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

namespace core-js/es6/object

module 'core-js/es6/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/es6/promise

module 'core-js/es6/promise' {}

variable Promise

const Promise: PromiseConstructor;

namespace core-js/es6/reflect

module 'core-js/es6/reflect' {}

variable Reflect

const Reflect: typeof core.Reflect;

namespace core-js/es6/regexp

module 'core-js/es6/regexp' {}

variable RegExp

const RegExp: { escape(str: string): string };

namespace core-js/es6/set

module 'core-js/es6/set' {}

variable Set

const Set: SetConstructor;

namespace core-js/es6/string

module 'core-js/es6/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/es6/symbol

module 'core-js/es6/symbol' {}

variable Symbol

const Symbol: SymbolConstructor;

namespace core-js/es6/weak-map

module 'core-js/es6/weak-map' {}

variable WeakMap

const WeakMap: WeakMapConstructor;

namespace core-js/es6/weak-set

module 'core-js/es6/weak-set' {}

variable WeakSet

const WeakSet: WeakSetConstructor;

namespace core-js/es7

module 'core-js/es7' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/es7.Reflect

namespace core-js/es7.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/es7/array

module 'core-js/es7/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/es7/map

module 'core-js/es7/map' {}

variable Map

const Map: MapConstructor;

namespace core-js/es7/object

module 'core-js/es7/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/es7/regexp

module 'core-js/es7/regexp' {}

variable RegExp

const RegExp: { escape(str: string): string };

namespace core-js/es7/set

module 'core-js/es7/set' {}

variable Set

const Set: SetConstructor;

namespace core-js/es7/string

module 'core-js/es7/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/fn/_

module 'core-js/fn/_' {}

namespace core-js/fn/$for

module 'core-js/fn/$for' {}

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

namespace core-js/fn/array

module 'core-js/fn/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/fn/array/concat

module 'core-js/fn/array/concat' {}

variable concat

const concat: <T>(array: ArrayLike<T>, ...items: (T | T[])[]) => T[];

namespace core-js/fn/array/copy-within

module 'core-js/fn/array/copy-within' {}

variable copyWithin

const copyWithin: <T>(
    array: ArrayLike<T>,
    target: number,
    start: number,
    end?: number
) => T[];

namespace core-js/fn/array/entries

module 'core-js/fn/array/entries' {}

variable entries

const entries: <T>(array: ArrayLike<T>) => IterableIterator<[number, T]>;

namespace core-js/fn/array/every

module 'core-js/fn/array/every' {}

variable every

const every: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => boolean,
    thisArg?: any
) => boolean;

namespace core-js/fn/array/fill

module 'core-js/fn/array/fill' {}

variable fill

const fill: <T>(array: ArrayLike<T>, value: T, start?: number, end?: number) => T[];

namespace core-js/fn/array/filter

module 'core-js/fn/array/filter' {}

variable filter

const filter: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => boolean,
    thisArg?: any
) => T[];

namespace core-js/fn/array/find

module 'core-js/fn/array/find' {}

variable find

const find: <T>(
    array: ArrayLike<T>,
    predicate: (value: T, index: number, obj: T[]) => boolean,
    thisArg?: any
) => T;

namespace core-js/fn/array/find-index

module 'core-js/fn/array/find-index' {}

variable findIndex

const findIndex: <T>(
    array: ArrayLike<T>,
    predicate: (value: T) => boolean,
    thisArg?: any
) => number;

namespace core-js/fn/array/for-each

module 'core-js/fn/array/for-each' {}

variable forEach

const forEach: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => void,
    thisArg?: any
) => void;

namespace core-js/fn/array/from

module 'core-js/fn/array/from' {}

variable from

const from: {
    <T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    <T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
};

namespace core-js/fn/array/includes

module 'core-js/fn/array/includes' {}

variable includes

const includes: <T>(array: ArrayLike<T>, value: T, fromIndex?: number) => boolean;

namespace core-js/fn/array/index-of

module 'core-js/fn/array/index-of' {}

variable indexOf

const indexOf: <T>(
    array: ArrayLike<T>,
    searchElement: T,
    fromIndex?: number
) => number;

namespace core-js/fn/array/is-array

module 'core-js/fn/array/is-array' {}

variable isArray

const isArray: (arg: any) => arg is any[];

namespace core-js/fn/array/join

module 'core-js/fn/array/join' {}

variable join

const join: <T>(array: ArrayLike<T>, separator?: string) => string;

namespace core-js/fn/array/keys

module 'core-js/fn/array/keys' {}

variable keys

const keys: <T>(array: ArrayLike<T>) => IterableIterator<number>;

namespace core-js/fn/array/last-index-of

module 'core-js/fn/array/last-index-of' {}

variable lastIndexOf

const lastIndexOf: <T>(
    array: ArrayLike<T>,
    earchElement: T,
    fromIndex?: number
) => number;

namespace core-js/fn/array/map

module 'core-js/fn/array/map' {}

variable map

const map: <T, U>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => U,
    thisArg?: any
) => U[];

namespace core-js/fn/array/of

module 'core-js/fn/array/of' {}

variable of

const of: <T>(...items: T[]) => T[];

namespace core-js/fn/array/pop

module 'core-js/fn/array/pop' {}

variable pop

const pop: <T>(array: ArrayLike<T>) => T;

namespace core-js/fn/array/push

module 'core-js/fn/array/push' {}

variable push

const push: <T>(array: ArrayLike<T>, ...items: T[]) => number;

namespace core-js/fn/array/reduce

module 'core-js/fn/array/reduce' {}

variable reduce

const reduce: {
    <T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    <T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
};

namespace core-js/fn/array/reduce-right

module 'core-js/fn/array/reduce-right' {}

variable reduceRight

const reduceRight: {
    <T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    <T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
};

namespace core-js/fn/array/reverse

module 'core-js/fn/array/reverse' {}

variable reverse

const reverse: <T>(array: ArrayLike<T>) => T[];

namespace core-js/fn/array/shift

module 'core-js/fn/array/shift' {}

variable shift

const shift: <T>(array: ArrayLike<T>) => T;

namespace core-js/fn/array/slice

module 'core-js/fn/array/slice' {}

variable slice

const slice: <T>(array: ArrayLike<T>, start?: number, end?: number) => T[];

namespace core-js/fn/array/some

module 'core-js/fn/array/some' {}

variable some

const some: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => boolean,
    thisArg?: any
) => boolean;

namespace core-js/fn/array/sort

module 'core-js/fn/array/sort' {}

variable sort

const sort: <T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number) => T[];

namespace core-js/fn/array/splice

module 'core-js/fn/array/splice' {}

variable splice

const splice: <T>(
    array: ArrayLike<T>,
    start: number,
    deleteCount?: number,
    ...items: T[]
) => T[];

namespace core-js/fn/array/turn

module 'core-js/fn/array/turn' {}

variable turn

const turn: {
    <T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    <T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/fn/array/unshift

module 'core-js/fn/array/unshift' {}

variable unshift

const unshift: <T>(array: ArrayLike<T>, ...items: T[]) => number;

namespace core-js/fn/array/values

module 'core-js/fn/array/values' {}

variable values

const values: <T>(array: ArrayLike<T>) => IterableIterator<T>;

namespace core-js/fn/clear-immediate

module 'core-js/fn/clear-immediate' {}

variable clearImmediate

const clearImmediate: (handle: number) => void;

namespace core-js/fn/date

module 'core-js/fn/date' {}

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

namespace core-js/fn/date/add-locale

module 'core-js/fn/date/add-locale' {}

variable addLocale

const addLocale: (lang: string, locale: core.Locale) => typeof core;

namespace core-js/fn/date/format

module 'core-js/fn/date/format' {}

variable format

const format: (date: Date, template: string, locale?: string) => string;

namespace core-js/fn/date/formatUTC

module 'core-js/fn/date/formatUTC' {}

variable formatUTC

const formatUTC: (date: Date, template: string, locale?: string) => string;

namespace core-js/fn/delay

module 'core-js/fn/delay' {}

variable delay

const delay: (msec: number) => Promise<void>;

namespace core-js/fn/dict

module 'core-js/fn/dict' {}

variable Dict

const Dict: DictConstructor;

namespace core-js/fn/function

module 'core-js/fn/function' {}

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

namespace core-js/fn/function/has-instance

module 'core-js/fn/function/has-instance' {}

function hasInstance

hasInstance: (value: any) => boolean;

namespace core-js/fn/function/name

module 'core-js/fn/function/name' {}

namespace core-js/fn/function/part

module 'core-js/fn/function/part' {}

variable part

const part: (target: Function, ...args: any[]) => any;

namespace core-js/fn/get-iterator

module 'core-js/fn/get-iterator' {}

variable getIterator

const getIterator: <T>(iterable: Iterable<T>) => Iterator<T, any, undefined>;

namespace core-js/fn/global

module 'core-js/fn/global' {}

variable global

const global: any;

namespace core-js/fn/is-iterable

module 'core-js/fn/is-iterable' {}

variable isIterable

const isIterable: (value: any) => boolean;

namespace core-js/fn/map

module 'core-js/fn/map' {}

variable Map

const Map: MapConstructor;

namespace core-js/fn/math

module 'core-js/fn/math' {}

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

namespace core-js/fn/math/acosh

module 'core-js/fn/math/acosh' {}

variable acosh

const acosh: (x: number) => number;

namespace core-js/fn/math/asinh

module 'core-js/fn/math/asinh' {}

variable asinh

const asinh: (x: number) => number;

namespace core-js/fn/math/atanh

module 'core-js/fn/math/atanh' {}

variable atanh

const atanh: (x: number) => number;

namespace core-js/fn/math/cbrt

module 'core-js/fn/math/cbrt' {}

variable cbrt

const cbrt: (x: number) => number;

namespace core-js/fn/math/clz32

module 'core-js/fn/math/clz32' {}

variable clz32

const clz32: (x: number) => number;

namespace core-js/fn/math/cosh

module 'core-js/fn/math/cosh' {}

variable cosh

const cosh: (x: number) => number;

namespace core-js/fn/math/expm1

module 'core-js/fn/math/expm1' {}

variable expm1

const expm1: (x: number) => number;

namespace core-js/fn/math/fround

module 'core-js/fn/math/fround' {}

variable fround

const fround: (x: number) => number;

namespace core-js/fn/math/hypot

module 'core-js/fn/math/hypot' {}

variable hypot

const hypot: (...values: number[]) => number;

namespace core-js/fn/math/imul

module 'core-js/fn/math/imul' {}

variable imul

const imul: (x: number, y: number) => number;

namespace core-js/fn/math/log10

module 'core-js/fn/math/log10' {}

variable log10

const log10: (x: number) => number;

namespace core-js/fn/math/log1p

module 'core-js/fn/math/log1p' {}

variable log1p

const log1p: (x: number) => number;

namespace core-js/fn/math/log2

module 'core-js/fn/math/log2' {}

variable log2

const log2: (x: number) => number;

namespace core-js/fn/math/sign

module 'core-js/fn/math/sign' {}

variable sign

const sign: (x: number) => number;

namespace core-js/fn/math/sinh

module 'core-js/fn/math/sinh' {}

variable sinh

const sinh: (x: number) => number;

namespace core-js/fn/math/tanh

module 'core-js/fn/math/tanh' {}

variable tanh

const tanh: (x: number) => number;

namespace core-js/fn/math/trunc

module 'core-js/fn/math/trunc' {}

variable trunc

const trunc: (x: number) => number;

namespace core-js/fn/number

module 'core-js/fn/number' {}

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

namespace core-js/fn/number/epsilon

module 'core-js/fn/number/epsilon' {}

variable EPSILON

const EPSILON: number;

namespace core-js/fn/number/is-finite

module 'core-js/fn/number/is-finite' {}

variable isFinite

const isFinite: (number: number) => boolean;

namespace core-js/fn/number/is-integer

module 'core-js/fn/number/is-integer' {}

variable isInteger

const isInteger: (number: number) => boolean;

namespace core-js/fn/number/is-nan

module 'core-js/fn/number/is-nan' {}

variable isNaN

const isNaN: (number: number) => boolean;

namespace core-js/fn/number/is-safe-integer

module 'core-js/fn/number/is-safe-integer' {}

variable isSafeInteger

const isSafeInteger: (number: number) => boolean;

namespace core-js/fn/number/max-safe-integer

module 'core-js/fn/number/max-safe-integer' {}

variable MAX_SAFE_INTEGER

const MAX_SAFE_INTEGER: number;

namespace core-js/fn/number/min-safe-integer

module 'core-js/fn/number/min-safe-integer' {}

variable MIN_SAFE_INTEGER

const MIN_SAFE_INTEGER: number;

namespace core-js/fn/number/parse-float

module 'core-js/fn/number/parse-float' {}

variable parseFloat

const parseFloat: (string: string) => number;

namespace core-js/fn/number/parse-int

module 'core-js/fn/number/parse-int' {}

variable parseInt

const parseInt: (string: string, radix?: number) => number;

namespace core-js/fn/number/random

module 'core-js/fn/number/random' {}

variable random

const random: (lim?: number) => number;

namespace core-js/fn/object

module 'core-js/fn/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/fn/object/assign

module 'core-js/fn/object/assign' {}

variable assign

const assign: (target: any, ...sources: any[]) => any;

namespace core-js/fn/object/classof

module 'core-js/fn/object/classof' {}

variable classof

const classof: (value: any) => string;

namespace core-js/fn/object/create

module 'core-js/fn/object/create' {}

variable create

const create: (o: any, properties?: PropertyDescriptorMap) => any;

namespace core-js/fn/object/define

module 'core-js/fn/object/define' {}

variable define

const define: <T>(target: T, mixin: any) => T;

namespace core-js/fn/object/define-properties

module 'core-js/fn/object/define-properties' {}

variable defineProperties

const defineProperties: (o: any, properties: PropertyDescriptorMap) => any;

namespace core-js/fn/object/define-property

module 'core-js/fn/object/define-property' {}

variable defineProperty

const defineProperty: (
    o: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => any;

namespace core-js/fn/object/entries

module 'core-js/fn/object/entries' {}

variable entries

const entries: (object: any) => any[];

namespace core-js/fn/object/freeze

module 'core-js/fn/object/freeze' {}

variable freeze

const freeze: <T>(o: T) => T;

namespace core-js/fn/object/get-own-property-descriptor

module 'core-js/fn/object/get-own-property-descriptor' {}

variable getOwnPropertyDescriptor

const getOwnPropertyDescriptor: (
    o: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

namespace core-js/fn/object/get-own-property-descriptors

module 'core-js/fn/object/get-own-property-descriptors' {}

variable getOwnPropertyDescriptors

const getOwnPropertyDescriptors: (object: any) => PropertyDescriptorMap;

namespace core-js/fn/object/get-own-property-names

module 'core-js/fn/object/get-own-property-names' {}

variable getOwnPropertyNames

const getOwnPropertyNames: (o: any) => string[];

namespace core-js/fn/object/get-own-property-symbols

module 'core-js/fn/object/get-own-property-symbols' {}

variable getOwnPropertySymbols

const getOwnPropertySymbols: (o: any) => symbol[];

namespace core-js/fn/object/get-prototype-of

module 'core-js/fn/object/get-prototype-of' {}

variable getPrototypeOf

const getPrototypeOf: (o: any) => any;

namespace core-js/fn/object/is

module 'core-js/fn/object/is' {}

variable is

const is: (value1: any, value2: any) => boolean;

namespace core-js/fn/object/is-extensible

module 'core-js/fn/object/is-extensible' {}

variable isExtensible

const isExtensible: (o: any) => boolean;

namespace core-js/fn/object/is-frozen

module 'core-js/fn/object/is-frozen' {}

variable isFrozen

const isFrozen: (o: any) => boolean;

namespace core-js/fn/object/is-object

module 'core-js/fn/object/is-object' {}

variable isObject

const isObject: (value: any) => boolean;

namespace core-js/fn/object/is-sealed

module 'core-js/fn/object/is-sealed' {}

variable isSealed

const isSealed: (o: any) => boolean;

namespace core-js/fn/object/keys

module 'core-js/fn/object/keys' {}

variable keys

const keys: (o: any) => string[];

namespace core-js/fn/object/make

module 'core-js/fn/object/make' {}

variable make

const make: <T>(proto: T, mixin?: any) => T;

namespace core-js/fn/object/prevent-extensions

module 'core-js/fn/object/prevent-extensions' {}

variable preventExtensions

const preventExtensions: <T>(o: T) => T;

namespace core-js/fn/object/seal

module 'core-js/fn/object/seal' {}

variable seal

const seal: <T>(o: T) => T;

namespace core-js/fn/object/set-prototype-of

module 'core-js/fn/object/set-prototype-of' {}

variable setPrototypeOf

const setPrototypeOf: (o: any, proto: any) => any;

namespace core-js/fn/object/values

module 'core-js/fn/object/values' {}

variable values

const values: (object: any) => any[];

namespace core-js/fn/promise

module 'core-js/fn/promise' {}

variable Promise

const Promise: PromiseConstructor;

namespace core-js/fn/reflect

module 'core-js/fn/reflect' {}

variable Reflect

const Reflect: typeof core.Reflect;

namespace core-js/fn/reflect/apply

module 'core-js/fn/reflect/apply' {}

variable apply

const apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

namespace core-js/fn/reflect/construct

module 'core-js/fn/reflect/construct' {}

variable construct

const construct: (target: Function, argumentsList: ArrayLike<any>) => any;

namespace core-js/fn/reflect/define-property

module 'core-js/fn/reflect/define-property' {}

variable defineProperty

const defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

namespace core-js/fn/reflect/delete-property

module 'core-js/fn/reflect/delete-property' {}

variable deleteProperty

const deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

namespace core-js/fn/reflect/get

module 'core-js/fn/reflect/get' {}

variable get

const get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

namespace core-js/fn/reflect/get-own-property-descriptor

module 'core-js/fn/reflect/get-own-property-descriptor' {}

variable getOwnPropertyDescriptor

const getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

namespace core-js/fn/reflect/get-prototype-of

module 'core-js/fn/reflect/get-prototype-of' {}

variable getPrototypeOf

const getPrototypeOf: (target: any) => any;

namespace core-js/fn/reflect/has

module 'core-js/fn/reflect/has' {}

variable has

const has: (target: any, propertyKey: string | symbol) => boolean;

namespace core-js/fn/reflect/is-extensible

module 'core-js/fn/reflect/is-extensible' {}

variable isExtensible

const isExtensible: (target: any) => boolean;

namespace core-js/fn/reflect/own-keys

module 'core-js/fn/reflect/own-keys' {}

variable ownKeys

const ownKeys: (target: any) => PropertyKey[];

namespace core-js/fn/reflect/prevent-extensions

module 'core-js/fn/reflect/prevent-extensions' {}

variable preventExtensions

const preventExtensions: (target: any) => boolean;

namespace core-js/fn/reflect/set

module 'core-js/fn/reflect/set' {}

variable set

const set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

namespace core-js/fn/reflect/set-prototype-of

module 'core-js/fn/reflect/set-prototype-of' {}

variable setPrototypeOf

const setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/fn/regexp

module 'core-js/fn/regexp' {}

variable RegExp

const RegExp: { escape(str: string): string };

namespace core-js/fn/regexp/escape

module 'core-js/fn/regexp/escape' {}

variable escape

const escape: (str: string) => string;

namespace core-js/fn/set

module 'core-js/fn/set' {}

variable Set

const Set: SetConstructor;

namespace core-js/fn/set-immediate

module 'core-js/fn/set-immediate' {}

variable setImmediate

const setImmediate: (expression: any, ...args: any[]) => number;

namespace core-js/fn/set-interval

module 'core-js/fn/set-interval' {}

variable setInterval

const setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

namespace core-js/fn/set-timeout

module 'core-js/fn/set-timeout' {}

variable setTimeout

const setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

namespace core-js/fn/string

module 'core-js/fn/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/fn/string/at

module 'core-js/fn/string/at' {}

variable at

const at: (text: string, index: number) => string;

namespace core-js/fn/string/code-point-at

module 'core-js/fn/string/code-point-at' {}

variable codePointAt

const codePointAt: (text: string, pos: number) => number;

namespace core-js/fn/string/ends-with

module 'core-js/fn/string/ends-with' {}

variable endsWith

const endsWith: (
    text: string,
    searchString: string,
    endPosition?: number
) => boolean;

namespace core-js/fn/string/escape-html

module 'core-js/fn/string/escape-html' {}

variable escapeHTML

const escapeHTML: (text: string) => string;

namespace core-js/fn/string/from-code-point

module 'core-js/fn/string/from-code-point' {}

variable fromCodePoint

const fromCodePoint: (...codePoints: number[]) => string;

namespace core-js/fn/string/includes

module 'core-js/fn/string/includes' {}

variable includes

const includes: (text: string, searchString: string, position?: number) => boolean;

namespace core-js/fn/string/pad-end

module 'core-js/fn/string/pad-end' {}

variable padEnd

const padEnd: (text: string, length: number, fillStr?: string) => string;

namespace core-js/fn/string/pad-start

module 'core-js/fn/string/pad-start' {}

variable padStart

const padStart: (text: string, length: number, fillStr?: string) => string;

namespace core-js/fn/string/raw

module 'core-js/fn/string/raw' {}

variable raw

const raw: (template: TemplateStringsArray, ...substitutions: any[]) => string;

namespace core-js/fn/string/repeat

module 'core-js/fn/string/repeat' {}

variable repeat

const repeat: (text: string, count: number) => string;

namespace core-js/fn/string/starts-with

module 'core-js/fn/string/starts-with' {}

variable startsWith

const startsWith: (text: string, searchString: string, position?: number) => boolean;

namespace core-js/fn/string/unescape-html

module 'core-js/fn/string/unescape-html' {}

variable unescapeHTML

const unescapeHTML: (text: string) => string;

namespace core-js/fn/symbol

module 'core-js/fn/symbol' {}

variable Symbol

const Symbol: SymbolConstructor;

namespace core-js/fn/symbol/for

module 'core-js/fn/symbol/for' {}

namespace core-js/fn/symbol/has-instance

module 'core-js/fn/symbol/has-instance' {}

variable hasInstance

const hasInstance: Symbol;

namespace core-js/fn/symbol/is-concat-spreadable

module 'core-js/fn/symbol/is-concat-spreadable' {}

variable isConcatSpreadable

const isConcatSpreadable: Symbol;

namespace core-js/fn/symbol/iterator

module 'core-js/fn/symbol/iterator' {}

variable iterator

const iterator: Symbol;

namespace core-js/fn/symbol/key-for

module 'core-js/fn/symbol/key-for' {}

variable keyFor

const keyFor: (sym: symbol) => string;

namespace core-js/fn/symbol/match

module 'core-js/fn/symbol/match' {}

variable match

const match: Symbol;

namespace core-js/fn/symbol/replace

module 'core-js/fn/symbol/replace' {}

variable replace

const replace: Symbol;

namespace core-js/fn/symbol/search

module 'core-js/fn/symbol/search' {}

variable search

const search: Symbol;

namespace core-js/fn/symbol/species

module 'core-js/fn/symbol/species' {}

variable species

const species: Symbol;

namespace core-js/fn/symbol/split

module 'core-js/fn/symbol/split' {}

variable split

const split: Symbol;

namespace core-js/fn/symbol/to-primitive

module 'core-js/fn/symbol/to-primitive' {}

variable toPrimitive

const toPrimitive: Symbol;

namespace core-js/fn/symbol/to-string-tag

module 'core-js/fn/symbol/to-string-tag' {}

variable toStringTag

const toStringTag: Symbol;

namespace core-js/fn/symbol/unscopables

module 'core-js/fn/symbol/unscopables' {}

variable unscopables

const unscopables: Symbol;

namespace core-js/fn/weak-map

module 'core-js/fn/weak-map' {}

variable WeakMap

const WeakMap: WeakMapConstructor;

namespace core-js/fn/weak-set

module 'core-js/fn/weak-set' {}

variable WeakSet

const WeakSet: WeakSetConstructor;

namespace core-js/js

module 'core-js/js' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/js.Reflect

namespace core-js/js.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/js/array

module 'core-js/js/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library

module 'core-js/library' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library.Reflect

namespace core-js/library.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/core

module 'core-js/library/core' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/core.Reflect

namespace core-js/library/core.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/core/_

module 'core-js/library/core/_' {}

namespace core-js/library/core/$for

module 'core-js/library/core/$for' {}

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

namespace core-js/library/core/array

module 'core-js/library/core/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library/core/date

module 'core-js/library/core/date' {}

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

namespace core-js/library/core/delay

module 'core-js/library/core/delay' {}

variable delay

const delay: (msec: number) => Promise<void>;

namespace core-js/library/core/dict

module 'core-js/library/core/dict' {}

variable Dict

const Dict: DictConstructor;

namespace core-js/library/core/function

module 'core-js/library/core/function' {}

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

namespace core-js/library/core/global

module 'core-js/library/core/global' {}

variable global

const global: any;

namespace core-js/library/core/number

module 'core-js/library/core/number' {}

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

namespace core-js/library/core/object

module 'core-js/library/core/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/library/core/string

module 'core-js/library/core/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/library/es5

module 'core-js/library/es5' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/es5.Reflect

namespace core-js/library/es5.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/es6

module 'core-js/library/es6' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/es6.Reflect

namespace core-js/library/es6.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/es6/array

module 'core-js/library/es6/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library/es6/function

module 'core-js/library/es6/function' {}

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

namespace core-js/library/es6/map

module 'core-js/library/es6/map' {}

variable Map

const Map: MapConstructor;

namespace core-js/library/es6/math

module 'core-js/library/es6/math' {}

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

namespace core-js/library/es6/number

module 'core-js/library/es6/number' {}

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

namespace core-js/library/es6/object

module 'core-js/library/es6/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/library/es6/promise

module 'core-js/library/es6/promise' {}

variable Promise

const Promise: PromiseConstructor;

namespace core-js/library/es6/reflect

module 'core-js/library/es6/reflect' {}

variable Reflect

const Reflect: typeof core.Reflect;

namespace core-js/library/es6/regexp

module 'core-js/library/es6/regexp' {}

variable RegExp

const RegExp: { escape(str: string): string };

namespace core-js/library/es6/set

module 'core-js/library/es6/set' {}

variable Set

const Set: SetConstructor;

namespace core-js/library/es6/string

module 'core-js/library/es6/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/library/es6/symbol

module 'core-js/library/es6/symbol' {}

variable Symbol

const Symbol: SymbolConstructor;

namespace core-js/library/es6/weak-map

module 'core-js/library/es6/weak-map' {}

variable WeakMap

const WeakMap: WeakMapConstructor;

namespace core-js/library/es6/weak-set

module 'core-js/library/es6/weak-set' {}

variable WeakSet

const WeakSet: WeakSetConstructor;

namespace core-js/library/es7

module 'core-js/library/es7' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/es7.Reflect

namespace core-js/library/es7.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/es7/array

module 'core-js/library/es7/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library/es7/map

module 'core-js/library/es7/map' {}

variable Map

const Map: MapConstructor;

namespace core-js/library/es7/object

module 'core-js/library/es7/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/library/es7/regexp

module 'core-js/library/es7/regexp' {}

variable RegExp

const RegExp: { escape(str: string): string };

namespace core-js/library/es7/set

module 'core-js/library/es7/set' {}

variable Set

const Set: SetConstructor;

namespace core-js/library/es7/string

module 'core-js/library/es7/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/library/fn/_

module 'core-js/library/fn/_' {}

namespace core-js/library/fn/$for

module 'core-js/library/fn/$for' {}

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

namespace core-js/library/fn/array

module 'core-js/library/fn/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library/fn/array/concat

module 'core-js/library/fn/array/concat' {}

variable concat

const concat: <T>(array: ArrayLike<T>, ...items: (T | T[])[]) => T[];

namespace core-js/library/fn/array/copy-within

module 'core-js/library/fn/array/copy-within' {}

variable copyWithin

const copyWithin: <T>(
    array: ArrayLike<T>,
    target: number,
    start: number,
    end?: number
) => T[];

namespace core-js/library/fn/array/entries

module 'core-js/library/fn/array/entries' {}

variable entries

const entries: <T>(array: ArrayLike<T>) => IterableIterator<[number, T]>;

namespace core-js/library/fn/array/every

module 'core-js/library/fn/array/every' {}

variable every

const every: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => boolean,
    thisArg?: any
) => boolean;

namespace core-js/library/fn/array/fill

module 'core-js/library/fn/array/fill' {}

variable fill

const fill: <T>(array: ArrayLike<T>, value: T, start?: number, end?: number) => T[];

namespace core-js/library/fn/array/filter

module 'core-js/library/fn/array/filter' {}

variable filter

const filter: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => boolean,
    thisArg?: any
) => T[];

namespace core-js/library/fn/array/find

module 'core-js/library/fn/array/find' {}

variable find

const find: <T>(
    array: ArrayLike<T>,
    predicate: (value: T, index: number, obj: T[]) => boolean,
    thisArg?: any
) => T;

namespace core-js/library/fn/array/find-index

module 'core-js/library/fn/array/find-index' {}

variable findIndex

const findIndex: <T>(
    array: ArrayLike<T>,
    predicate: (value: T) => boolean,
    thisArg?: any
) => number;

namespace core-js/library/fn/array/for-each

module 'core-js/library/fn/array/for-each' {}

variable forEach

const forEach: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => void,
    thisArg?: any
) => void;

namespace core-js/library/fn/array/from

module 'core-js/library/fn/array/from' {}

variable from

const from: {
    <T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    <T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
};

namespace core-js/library/fn/array/includes

module 'core-js/library/fn/array/includes' {}

variable includes

const includes: <T>(array: ArrayLike<T>, value: T, fromIndex?: number) => boolean;

namespace core-js/library/fn/array/index-of

module 'core-js/library/fn/array/index-of' {}

variable indexOf

const indexOf: <T>(
    array: ArrayLike<T>,
    searchElement: T,
    fromIndex?: number
) => number;

namespace core-js/library/fn/array/is-array

module 'core-js/library/fn/array/is-array' {}

variable isArray

const isArray: (arg: any) => arg is any[];

namespace core-js/library/fn/array/join

module 'core-js/library/fn/array/join' {}

variable join

const join: <T>(array: ArrayLike<T>, separator?: string) => string;

namespace core-js/library/fn/array/keys

module 'core-js/library/fn/array/keys' {}

variable keys

const keys: <T>(array: ArrayLike<T>) => IterableIterator<number>;

namespace core-js/library/fn/array/last-index-of

module 'core-js/library/fn/array/last-index-of' {}

variable lastIndexOf

const lastIndexOf: <T>(
    array: ArrayLike<T>,
    earchElement: T,
    fromIndex?: number
) => number;

namespace core-js/library/fn/array/map

module 'core-js/library/fn/array/map' {}

variable map

const map: <T, U>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => U,
    thisArg?: any
) => U[];

namespace core-js/library/fn/array/of

module 'core-js/library/fn/array/of' {}

variable of

const of: <T>(...items: T[]) => T[];

namespace core-js/library/fn/array/pop

module 'core-js/library/fn/array/pop' {}

variable pop

const pop: <T>(array: ArrayLike<T>) => T;

namespace core-js/library/fn/array/push

module 'core-js/library/fn/array/push' {}

variable push

const push: <T>(array: ArrayLike<T>, ...items: T[]) => number;

namespace core-js/library/fn/array/reduce

module 'core-js/library/fn/array/reduce' {}

variable reduce

const reduce: {
    <T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    <T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
};

namespace core-js/library/fn/array/reduce-right

module 'core-js/library/fn/array/reduce-right' {}

variable reduceRight

const reduceRight: {
    <T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    <T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
};

namespace core-js/library/fn/array/reverse

module 'core-js/library/fn/array/reverse' {}

variable reverse

const reverse: <T>(array: ArrayLike<T>) => T[];

namespace core-js/library/fn/array/shift

module 'core-js/library/fn/array/shift' {}

variable shift

const shift: <T>(array: ArrayLike<T>) => T;

namespace core-js/library/fn/array/slice

module 'core-js/library/fn/array/slice' {}

variable slice

const slice: <T>(array: ArrayLike<T>, start?: number, end?: number) => T[];

namespace core-js/library/fn/array/some

module 'core-js/library/fn/array/some' {}

variable some

const some: <T>(
    array: ArrayLike<T>,
    callbackfn: (value: T, index: number, array: T[]) => boolean,
    thisArg?: any
) => boolean;

namespace core-js/library/fn/array/sort

module 'core-js/library/fn/array/sort' {}

variable sort

const sort: <T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number) => T[];

namespace core-js/library/fn/array/splice

module 'core-js/library/fn/array/splice' {}

variable splice

const splice: <T>(
    array: ArrayLike<T>,
    start: number,
    deleteCount?: number,
    ...items: T[]
) => T[];

namespace core-js/library/fn/array/turn

module 'core-js/library/fn/array/turn' {}

variable turn

const turn: {
    <T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    <T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library/fn/array/unshift

module 'core-js/library/fn/array/unshift' {}

variable unshift

const unshift: <T>(array: ArrayLike<T>, ...items: T[]) => number;

namespace core-js/library/fn/array/values

module 'core-js/library/fn/array/values' {}

variable values

const values: <T>(array: ArrayLike<T>) => IterableIterator<T>;

namespace core-js/library/fn/clear-immediate

module 'core-js/library/fn/clear-immediate' {}

variable clearImmediate

const clearImmediate: (handle: number) => void;

namespace core-js/library/fn/date

module 'core-js/library/fn/date' {}

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

namespace core-js/library/fn/date/add-locale

module 'core-js/library/fn/date/add-locale' {}

variable addLocale

const addLocale: (lang: string, locale: core.Locale) => typeof core;

namespace core-js/library/fn/date/format

module 'core-js/library/fn/date/format' {}

variable format

const format: (date: Date, template: string, locale?: string) => string;

namespace core-js/library/fn/date/formatUTC

module 'core-js/library/fn/date/formatUTC' {}

variable formatUTC

const formatUTC: (date: Date, template: string, locale?: string) => string;

namespace core-js/library/fn/delay

module 'core-js/library/fn/delay' {}

variable delay

const delay: (msec: number) => Promise<void>;

namespace core-js/library/fn/dict

module 'core-js/library/fn/dict' {}

variable Dict

const Dict: DictConstructor;

namespace core-js/library/fn/function

module 'core-js/library/fn/function' {}

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

namespace core-js/library/fn/function/has-instance

module 'core-js/library/fn/function/has-instance' {}

function hasInstance

hasInstance: (value: any) => boolean;

namespace core-js/library/fn/function/name

module 'core-js/library/fn/function/name' {}

namespace core-js/library/fn/function/part

module 'core-js/library/fn/function/part' {}

variable part

const part: (target: Function, ...args: any[]) => any;

namespace core-js/library/fn/get-iterator

module 'core-js/library/fn/get-iterator' {}

variable getIterator

const getIterator: <T>(iterable: Iterable<T>) => Iterator<T, any, undefined>;

namespace core-js/library/fn/global

module 'core-js/library/fn/global' {}

variable global

const global: any;

namespace core-js/library/fn/is-iterable

module 'core-js/library/fn/is-iterable' {}

variable isIterable

const isIterable: (value: any) => boolean;

namespace core-js/library/fn/map

module 'core-js/library/fn/map' {}

variable Map

const Map: MapConstructor;

namespace core-js/library/fn/math

module 'core-js/library/fn/math' {}

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

namespace core-js/library/fn/math/acosh

module 'core-js/library/fn/math/acosh' {}

variable acosh

const acosh: (x: number) => number;

namespace core-js/library/fn/math/asinh

module 'core-js/library/fn/math/asinh' {}

variable asinh

const asinh: (x: number) => number;

namespace core-js/library/fn/math/atanh

module 'core-js/library/fn/math/atanh' {}

variable atanh

const atanh: (x: number) => number;

namespace core-js/library/fn/math/cbrt

module 'core-js/library/fn/math/cbrt' {}

variable cbrt

const cbrt: (x: number) => number;

namespace core-js/library/fn/math/clz32

module 'core-js/library/fn/math/clz32' {}

variable clz32

const clz32: (x: number) => number;

namespace core-js/library/fn/math/cosh

module 'core-js/library/fn/math/cosh' {}

variable cosh

const cosh: (x: number) => number;

namespace core-js/library/fn/math/expm1

module 'core-js/library/fn/math/expm1' {}

variable expm1

const expm1: (x: number) => number;

namespace core-js/library/fn/math/fround

module 'core-js/library/fn/math/fround' {}

variable fround

const fround: (x: number) => number;

namespace core-js/library/fn/math/hypot

module 'core-js/library/fn/math/hypot' {}

variable hypot

const hypot: (...values: number[]) => number;

namespace core-js/library/fn/math/imul

module 'core-js/library/fn/math/imul' {}

variable imul

const imul: (x: number, y: number) => number;

namespace core-js/library/fn/math/log10

module 'core-js/library/fn/math/log10' {}

variable log10

const log10: (x: number) => number;

namespace core-js/library/fn/math/log1p

module 'core-js/library/fn/math/log1p' {}

variable log1p

const log1p: (x: number) => number;

namespace core-js/library/fn/math/log2

module 'core-js/library/fn/math/log2' {}

variable log2

const log2: (x: number) => number;

namespace core-js/library/fn/math/sign

module 'core-js/library/fn/math/sign' {}

variable sign

const sign: (x: number) => number;

namespace core-js/library/fn/math/sinh

module 'core-js/library/fn/math/sinh' {}

variable sinh

const sinh: (x: number) => number;

namespace core-js/library/fn/math/tanh

module 'core-js/library/fn/math/tanh' {}

variable tanh

const tanh: (x: number) => number;

namespace core-js/library/fn/math/trunc

module 'core-js/library/fn/math/trunc' {}

variable trunc

const trunc: (x: number) => number;

namespace core-js/library/fn/number

module 'core-js/library/fn/number' {}

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

namespace core-js/library/fn/number/epsilon

module 'core-js/library/fn/number/epsilon' {}

variable EPSILON

const EPSILON: number;

namespace core-js/library/fn/number/is-finite

module 'core-js/library/fn/number/is-finite' {}

variable isFinite

const isFinite: (number: number) => boolean;

namespace core-js/library/fn/number/is-integer

module 'core-js/library/fn/number/is-integer' {}

variable isInteger

const isInteger: (number: number) => boolean;

namespace core-js/library/fn/number/is-nan

module 'core-js/library/fn/number/is-nan' {}

variable isNaN

const isNaN: (number: number) => boolean;

namespace core-js/library/fn/number/is-safe-integer

module 'core-js/library/fn/number/is-safe-integer' {}

variable isSafeInteger

const isSafeInteger: (number: number) => boolean;

namespace core-js/library/fn/number/max-safe-integer

module 'core-js/library/fn/number/max-safe-integer' {}

variable MAX_SAFE_INTEGER

const MAX_SAFE_INTEGER: number;

namespace core-js/library/fn/number/min-safe-integer

module 'core-js/library/fn/number/min-safe-integer' {}

variable MIN_SAFE_INTEGER

const MIN_SAFE_INTEGER: number;

namespace core-js/library/fn/number/parse-float

module 'core-js/library/fn/number/parse-float' {}

variable parseFloat

const parseFloat: (string: string) => number;

namespace core-js/library/fn/number/parse-int

module 'core-js/library/fn/number/parse-int' {}

variable parseInt

const parseInt: (string: string, radix?: number) => number;

namespace core-js/library/fn/number/random

module 'core-js/library/fn/number/random' {}

variable random

const random: (lim?: number) => number;

namespace core-js/library/fn/object

module 'core-js/library/fn/object' {}

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

namespace core-js/library/fn/object/assign

module 'core-js/library/fn/object/assign' {}

variable assign

const assign: (target: any, ...sources: any[]) => any;

namespace core-js/library/fn/object/classof

module 'core-js/library/fn/object/classof' {}

variable classof

const classof: (value: any) => string;

namespace core-js/library/fn/object/create

module 'core-js/library/fn/object/create' {}

variable create

const create: (o: any, properties?: PropertyDescriptorMap) => any;

namespace core-js/library/fn/object/define

module 'core-js/library/fn/object/define' {}

variable define

const define: <T>(target: T, mixin: any) => T;

namespace core-js/library/fn/object/define-properties

module 'core-js/library/fn/object/define-properties' {}

variable defineProperties

const defineProperties: (o: any, properties: PropertyDescriptorMap) => any;

namespace core-js/library/fn/object/define-property

module 'core-js/library/fn/object/define-property' {}

variable defineProperty

const defineProperty: (
    o: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => any;

namespace core-js/library/fn/object/entries

module 'core-js/library/fn/object/entries' {}

variable entries

const entries: (object: any) => any[];

namespace core-js/library/fn/object/freeze

module 'core-js/library/fn/object/freeze' {}

variable freeze

const freeze: <T>(o: T) => T;

namespace core-js/library/fn/object/get-own-property-descriptor

module 'core-js/library/fn/object/get-own-property-descriptor' {}

variable getOwnPropertyDescriptor

const getOwnPropertyDescriptor: (
    o: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

namespace core-js/library/fn/object/get-own-property-descriptors

module 'core-js/library/fn/object/get-own-property-descriptors' {}

variable getOwnPropertyDescriptors

const getOwnPropertyDescriptors: (object: any) => PropertyDescriptorMap;

namespace core-js/library/fn/object/get-own-property-names

module 'core-js/library/fn/object/get-own-property-names' {}

variable getOwnPropertyNames

const getOwnPropertyNames: (o: any) => string[];

namespace core-js/library/fn/object/get-own-property-symbols

module 'core-js/library/fn/object/get-own-property-symbols' {}

variable getOwnPropertySymbols

const getOwnPropertySymbols: (o: any) => symbol[];

namespace core-js/library/fn/object/get-prototype-of

module 'core-js/library/fn/object/get-prototype-of' {}

variable getPrototypeOf

const getPrototypeOf: (o: any) => any;

namespace core-js/library/fn/object/is

module 'core-js/library/fn/object/is' {}

variable is

const is: (value1: any, value2: any) => boolean;

namespace core-js/library/fn/object/is-extensible

module 'core-js/library/fn/object/is-extensible' {}

variable isExtensible

const isExtensible: (o: any) => boolean;

namespace core-js/library/fn/object/is-frozen

module 'core-js/library/fn/object/is-frozen' {}

variable isFrozen

const isFrozen: (o: any) => boolean;

namespace core-js/library/fn/object/is-object

module 'core-js/library/fn/object/is-object' {}

variable isObject

const isObject: (value: any) => boolean;

namespace core-js/library/fn/object/is-sealed

module 'core-js/library/fn/object/is-sealed' {}

variable isSealed

const isSealed: (o: any) => boolean;

namespace core-js/library/fn/object/keys

module 'core-js/library/fn/object/keys' {}

variable keys

const keys: (o: any) => string[];

namespace core-js/library/fn/object/make

module 'core-js/library/fn/object/make' {}

variable make

const make: <T>(proto: T, mixin?: any) => T;

namespace core-js/library/fn/object/prevent-extensions

module 'core-js/library/fn/object/prevent-extensions' {}

variable preventExtensions

const preventExtensions: <T>(o: T) => T;

namespace core-js/library/fn/object/seal

module 'core-js/library/fn/object/seal' {}

variable seal

const seal: <T>(o: T) => T;

namespace core-js/library/fn/object/set-prototype-of

module 'core-js/library/fn/object/set-prototype-of' {}

variable setPrototypeOf

const setPrototypeOf: (o: any, proto: any) => any;

namespace core-js/library/fn/object/values

module 'core-js/library/fn/object/values' {}

variable values

const values: (object: any) => any[];

namespace core-js/library/fn/promise

module 'core-js/library/fn/promise' {}

variable Promise

const Promise: PromiseConstructor;

namespace core-js/library/fn/reflect

module 'core-js/library/fn/reflect' {}

variable Reflect

const Reflect: typeof core.Reflect;

namespace core-js/library/fn/reflect/apply

module 'core-js/library/fn/reflect/apply' {}

variable apply

const apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

namespace core-js/library/fn/reflect/construct

module 'core-js/library/fn/reflect/construct' {}

variable construct

const construct: (target: Function, argumentsList: ArrayLike<any>) => any;

namespace core-js/library/fn/reflect/define-property

module 'core-js/library/fn/reflect/define-property' {}

variable defineProperty

const defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

namespace core-js/library/fn/reflect/delete-property

module 'core-js/library/fn/reflect/delete-property' {}

variable deleteProperty

const deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

namespace core-js/library/fn/reflect/es7/define-metadata

module 'core-js/library/fn/reflect/es7/define-metadata' {}

variable defineMetadata

const defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

namespace core-js/library/fn/reflect/es7/delete-metadata

module 'core-js/library/fn/reflect/es7/delete-metadata' {}

variable deleteMetadata

const deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

namespace core-js/library/fn/reflect/es7/get-metadata

module 'core-js/library/fn/reflect/es7/get-metadata' {}

variable getMetadata

const getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

namespace core-js/library/fn/reflect/es7/get-metadata-keys

module 'core-js/library/fn/reflect/es7/get-metadata-keys' {}

variable getMetadataKeys

const getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

namespace core-js/library/fn/reflect/es7/get-own-metadata

module 'core-js/library/fn/reflect/es7/get-own-metadata' {}

variable getOwnMetadata

const getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

namespace core-js/library/fn/reflect/es7/get-own-metadata-keys

module "core-js/library/fn/reflect/es7/get-own-metadata-keys'" {}

variable getOwnMetadataKeys

const getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

namespace core-js/library/fn/reflect/es7/has-metadata

module "core-js/library/fn/reflect/es7/has-metadata'" {}

variable hasMetadata

const hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

namespace core-js/library/fn/reflect/es7/has-own-metadata

module "core-js/library/fn/reflect/es7/has-own-metadata'" {}

variable hasOwnMetadata

const hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

namespace core-js/library/fn/reflect/es7/metadata

module "core-js/library/fn/reflect/es7/metadata'" {}

variable metadata

const metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

namespace core-js/library/fn/reflect/get

module 'core-js/library/fn/reflect/get' {}

variable get

const get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

namespace core-js/library/fn/reflect/get-own-property-descriptor

module 'core-js/library/fn/reflect/get-own-property-descriptor' {}

variable getOwnPropertyDescriptor

const getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

namespace core-js/library/fn/reflect/get-prototype-of

module 'core-js/library/fn/reflect/get-prototype-of' {}

variable getPrototypeOf

const getPrototypeOf: (target: any) => any;

namespace core-js/library/fn/reflect/has

module 'core-js/library/fn/reflect/has' {}

variable has

const has: (target: any, propertyKey: string | symbol) => boolean;

namespace core-js/library/fn/reflect/is-extensible

module 'core-js/library/fn/reflect/is-extensible' {}

variable isExtensible

const isExtensible: (target: any) => boolean;

namespace core-js/library/fn/reflect/own-keys

module 'core-js/library/fn/reflect/own-keys' {}

variable ownKeys

const ownKeys: (target: any) => PropertyKey[];

namespace core-js/library/fn/reflect/prevent-extensions

module 'core-js/library/fn/reflect/prevent-extensions' {}

variable preventExtensions

const preventExtensions: (target: any) => boolean;

namespace core-js/library/fn/reflect/set

module 'core-js/library/fn/reflect/set' {}

variable set

const set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

namespace core-js/library/fn/reflect/set-prototype-of

module 'core-js/library/fn/reflect/set-prototype-of' {}

variable setPrototypeOf

const setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/fn/regexp

module 'core-js/library/fn/regexp' {}

variable RegExp

const RegExp: { escape(str: string): string };

namespace core-js/library/fn/regexp/escape

module 'core-js/library/fn/regexp/escape' {}

variable escape

const escape: (str: string) => string;

namespace core-js/library/fn/set

module 'core-js/library/fn/set' {}

variable Set

const Set: SetConstructor;

namespace core-js/library/fn/set-immediate

module 'core-js/library/fn/set-immediate' {}

variable setImmediate

const setImmediate: (expression: any, ...args: any[]) => number;

namespace core-js/library/fn/set-interval

module 'core-js/library/fn/set-interval' {}

variable setInterval

const setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

namespace core-js/library/fn/set-timeout

module 'core-js/library/fn/set-timeout' {}

variable setTimeout

const setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

namespace core-js/library/fn/string

module 'core-js/library/fn/string' {}

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

namespace core-js/library/fn/string/at

module 'core-js/library/fn/string/at' {}

variable at

const at: (text: string, index: number) => string;

namespace core-js/library/fn/string/code-point-at

module 'core-js/library/fn/string/code-point-at' {}

variable codePointAt

const codePointAt: (text: string, pos: number) => number;

namespace core-js/library/fn/string/ends-with

module 'core-js/library/fn/string/ends-with' {}

variable endsWith

const endsWith: (
    text: string,
    searchString: string,
    endPosition?: number
) => boolean;

namespace core-js/library/fn/string/escape-html

module 'core-js/library/fn/string/escape-html' {}

variable escapeHTML

const escapeHTML: (text: string) => string;

namespace core-js/library/fn/string/from-code-point

module 'core-js/library/fn/string/from-code-point' {}

variable fromCodePoint

const fromCodePoint: (...codePoints: number[]) => string;

namespace core-js/library/fn/string/includes

module 'core-js/library/fn/string/includes' {}

variable includes

const includes: (text: string, searchString: string, position?: number) => boolean;

namespace core-js/library/fn/string/pad-end

module 'core-js/library/fn/string/pad-end' {}

variable padEnd

const padEnd: (text: string, length: number, fillStr?: string) => string;

namespace core-js/library/fn/string/pad-start

module 'core-js/library/fn/string/pad-start' {}

variable padStart

const padStart: (text: string, length: number, fillStr?: string) => string;

namespace core-js/library/fn/string/raw

module 'core-js/library/fn/string/raw' {}

variable raw

const raw: (template: TemplateStringsArray, ...substitutions: any[]) => string;

namespace core-js/library/fn/string/repeat

module 'core-js/library/fn/string/repeat' {}

variable repeat

const repeat: (text: string, count: number) => string;

namespace core-js/library/fn/string/starts-with

module 'core-js/library/fn/string/starts-with' {}

variable startsWith

const startsWith: (text: string, searchString: string, position?: number) => boolean;

namespace core-js/library/fn/string/unescape-html

module 'core-js/library/fn/string/unescape-html' {}

variable unescapeHTML

const unescapeHTML: (text: string) => string;

namespace core-js/library/fn/symbol

module 'core-js/library/fn/symbol' {}

variable Symbol

const Symbol: SymbolConstructor;

namespace core-js/library/fn/symbol/for

module 'core-js/library/fn/symbol/for' {}

namespace core-js/library/fn/symbol/has-instance

module 'core-js/library/fn/symbol/has-instance' {}

variable hasInstance

const hasInstance: Symbol;

namespace core-js/library/fn/symbol/is-concat-spreadable

module 'core-js/library/fn/symbol/is-concat-spreadable' {}

variable isConcatSpreadable

const isConcatSpreadable: Symbol;

namespace core-js/library/fn/symbol/iterator

module 'core-js/library/fn/symbol/iterator' {}

variable iterator

const iterator: Symbol;

namespace core-js/library/fn/symbol/key-for

module 'core-js/library/fn/symbol/key-for' {}

variable keyFor

const keyFor: (sym: symbol) => string;

namespace core-js/library/fn/symbol/match

module 'core-js/library/fn/symbol/match' {}

variable match

const match: Symbol;

namespace core-js/library/fn/symbol/replace

module 'core-js/library/fn/symbol/replace' {}

variable replace

const replace: Symbol;

namespace core-js/library/fn/symbol/search

module 'core-js/library/fn/symbol/search' {}

variable search

const search: Symbol;

namespace core-js/library/fn/symbol/species

module 'core-js/library/fn/symbol/species' {}

variable species

const species: Symbol;

namespace core-js/library/fn/symbol/split

module 'core-js/library/fn/symbol/split' {}

variable split

const split: Symbol;

namespace core-js/library/fn/symbol/to-primitive

module 'core-js/library/fn/symbol/to-primitive' {}

variable toPrimitive

const toPrimitive: Symbol;

namespace core-js/library/fn/symbol/to-string-tag

module 'core-js/library/fn/symbol/to-string-tag' {}

variable toStringTag

const toStringTag: Symbol;

namespace core-js/library/fn/symbol/unscopables

module 'core-js/library/fn/symbol/unscopables' {}

variable unscopables

const unscopables: Symbol;

namespace core-js/library/fn/weak-map

module 'core-js/library/fn/weak-map' {}

variable WeakMap

const WeakMap: WeakMapConstructor;

namespace core-js/library/fn/weak-set

module 'core-js/library/fn/weak-set' {}

variable WeakSet

const WeakSet: WeakSetConstructor;

namespace core-js/library/js

module 'core-js/library/js' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/js.Reflect

namespace core-js/library/js.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/js/array

module 'core-js/library/js/array' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

namespace core-js/library/shim

module 'core-js/library/shim' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/shim.Reflect

namespace core-js/library/shim.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/web

module 'core-js/library/web' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/web.Reflect

namespace core-js/library/web.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/web/dom

module 'core-js/library/web/dom' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/web/dom.Reflect

namespace core-js/library/web/dom.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/web/immediate

module 'core-js/library/web/immediate' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/web/immediate.Reflect

namespace core-js/library/web/immediate.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/library/web/timers

module 'core-js/library/web/timers' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/library/web/timers.Reflect

namespace core-js/library/web/timers.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/shim

module 'core-js/shim' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/shim.Reflect

namespace core-js/shim.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/web

module 'core-js/web' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/web.Reflect

namespace core-js/web.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/web/dom

module 'core-js/web/dom' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/web/dom.Reflect

namespace core-js/web/dom.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/web/immediate

module 'core-js/web/immediate' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/web/immediate.Reflect

namespace core-js/web/immediate.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core-js/web/timers

module 'core-js/web/timers' {}

variable Array

const Array: {
    from<T, U>(
        arrayLike: ArrayLike<T> | Iterable<T>,
        mapfn: (v: T, k: number) => U,
        thisArg?: any
    ): U[];
    from<T>(arrayLike: ArrayLike<T> | Iterable<T>): T[];
    of<T>(...items: T[]): T[];
    isArray(arg: any): arg is any[];
    push<T>(array: ArrayLike<T>, ...items: T[]): number;
    pop<T>(array: ArrayLike<T>): T;
    concat<T>(array: ArrayLike<T>, ...items: (T | T[])[]): T[];
    join<T>(array: ArrayLike<T>, separator?: string): string;
    reverse<T>(array: ArrayLike<T>): T[];
    shift<T>(array: ArrayLike<T>): T;
    slice<T>(array: ArrayLike<T>, start?: number, end?: number): T[];
    sort<T>(array: ArrayLike<T>, compareFn?: (a: T, b: T) => number): T[];
    splice<T>(
        array: ArrayLike<T>,
        start: number,
        deleteCount?: number,
        ...items: T[]
    ): T[];
    unshift<T>(array: ArrayLike<T>, ...items: T[]): number;
    indexOf<T>(array: ArrayLike<T>, searchElement: T, fromIndex?: number): number;
    lastIndexOf<T>(array: ArrayLike<T>, earchElement: T, fromIndex?: number): number;
    every<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    some<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): boolean;
    forEach<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => void,
        thisArg?: any
    ): void;
    map<T, U>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => U,
        thisArg?: any
    ): U[];
    filter<T>(
        array: ArrayLike<T>,
        callbackfn: (value: T, index: number, array: T[]) => boolean,
        thisArg?: any
    ): T[];
    reduce<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduce<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    reduceRight<T>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: T,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => T,
        initialValue?: T
    ): T;
    reduceRight<T, U>(
        array: ArrayLike<T>,
        callbackfn: (
            previousValue: U,
            currentValue: T,
            currentIndex: number,
            array: T[]
        ) => U,
        initialValue: U
    ): U;
    entries<T>(array: ArrayLike<T>): IterableIterator<[number, T]>;
    keys<T>(array: ArrayLike<T>): IterableIterator<number>;
    values<T>(array: ArrayLike<T>): IterableIterator<T>;
    find<T>(
        array: ArrayLike<T>,
        predicate: (value: T, index: number, obj: T[]) => boolean,
        thisArg?: any
    ): T;
    findIndex<T>(
        array: ArrayLike<T>,
        predicate: (value: T) => boolean,
        thisArg?: any
    ): number;
    fill<T>(array: ArrayLike<T>, value: T, start?: number, end?: number): T[];
    copyWithin<T>(
        array: ArrayLike<T>,
        target: number,
        start: number,
        end?: number
    ): T[];
    includes<T>(array: ArrayLike<T>, value: T, fromIndex?: number): boolean;
    turn<T>(
        array: ArrayLike<T>,
        callbackfn: (memo: T[], value: T, index: number, array: T[]) => void,
        memo?: T[]
    ): T[];
    turn<T, U>(
        array: ArrayLike<T>,
        callbackfn: (memo: U, value: T, index: number, array: T[]) => void,
        memo?: U
    ): U;
};

variable Date

const Date: {
    now(): number;
    toISOString(date: Date): string;
    format(date: Date, template: string, locale?: string): string;
    formatUTC(date: Date, template: string, locale?: string): string;
};

variable Dict

const Dict: DictConstructor;

variable Function

const Function: {
    bind(target: Function, thisArg: any, ...argArray: any[]): any;
    part(target: Function, ...args: any[]): any;
};

variable global

const global: any;

variable Map

const Map: MapConstructor;

variable Math

const Math: {
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
};

variable Number

const Number: {
    EPSILON: number;
    isFinite(number: number): boolean;
    isInteger(number: number): boolean;
    isNaN(number: number): boolean;
    isSafeInteger(number: number): boolean;
    MAX_SAFE_INTEGER: number;
    MIN_SAFE_INTEGER: number;
    parseFloat(string: string): number;
    parseInt(string: string, radix?: number): number;
    clz32(x: number): number;
    imul(x: number, y: number): number;
    sign(x: number): number;
    log10(x: number): number;
    log2(x: number): number;
    log1p(x: number): number;
    expm1(x: number): number;
    cosh(x: number): number;
    sinh(x: number): number;
    tanh(x: number): number;
    acosh(x: number): number;
    asinh(x: number): number;
    atanh(x: number): number;
    hypot(...values: number[]): number;
    trunc(x: number): number;
    fround(x: number): number;
    cbrt(x: number): number;
    random(lim?: number): number;
};

variable Object

const Object: {
    getPrototypeOf(o: any): any;
    getOwnPropertyNames(o: any): string[];
    create(o: any, properties?: PropertyDescriptorMap): any;
    defineProperties(o: any, properties: PropertyDescriptorMap): any;
    seal<T>(o: T): T;
    freeze<T>(o: T): T;
    preventExtensions<T>(o: T): T;
    isSealed(o: any): boolean;
    isFrozen(o: any): boolean;
    isExtensible(o: any): boolean;
    keys(o: any): string[];
    assign(target: any, ...sources: any[]): any;
    is(value1: any, value2: any): boolean;
    setPrototypeOf(o: any, proto: any): any;
    getOwnPropertySymbols(o: any): symbol[];
    getOwnPropertyDescriptor(o: any, propertyKey: PropertyKey): PropertyDescriptor;
    defineProperty(
        o: any,
        propertyKey: PropertyKey,
        attributes: PropertyDescriptor
    ): any;
    values(object: any): any[];
    entries(object: any): any[];
    getOwnPropertyDescriptors(object: any): PropertyDescriptorMap;
    isObject(value: any): boolean;
    classof(value: any): string;
    define<T>(target: T, mixin: any): T;
    make<T>(proto: T, mixin?: any): T;
};

variable Promise

const Promise: PromiseConstructor;

variable RegExp

const RegExp: { escape(str: string): string };

variable Set

const Set: SetConstructor;

variable String

const String: {
    codePointAt(text: string, pos: number): number;
    includes(text: string, searchString: string, position?: number): boolean;
    endsWith(text: string, searchString: string, endPosition?: number): boolean;
    repeat(text: string, count: number): string;
    fromCodePoint(...codePoints: number[]): string;
    raw(template: TemplateStringsArray, ...substitutions: any[]): string;
    startsWith(text: string, searchString: string, position?: number): boolean;
    at(text: string, index: number): string;
    padStart(text: string, length: number, fillStr?: string): string;
    padEnd(text: string, length: number, fillStr?: string): string;
    escapeHTML(text: string): string;
    unescapeHTML(text: string): string;
};

variable Symbol

const Symbol: SymbolConstructor;

variable version

const version: string;

variable WeakMap

const WeakMap: WeakMapConstructor;

variable WeakSet

const WeakSet: WeakSetConstructor;

function $for

$for: <T>(iterable: Iterable<T>) => $for<T>;

function addLocale

addLocale: (lang: string, locale: Locale) => typeof core;

function clearImmediate

clearImmediate: (handle: number) => void;

function delay

delay: (msec: number) => Promise<void>;

function getIterator

getIterator: <T>(iterable: Iterable<T>) => Iterator<T>;

function isIterable

isIterable: (value: any) => boolean;

function locale

locale: (lang?: string) => string;

function setImmediate

setImmediate: (expression: any, ...args: any[]) => number;

function setInterval

setInterval: (handler: any, timeout?: any, ...args: any[]) => number;

function setTimeout

setTimeout: (handler: any, timeout?: any, ...args: any[]) => number;

interface Locale

interface Locale {}

property months

months: string;

property weekdays

weekdays: string;

namespace core-js/web/timers.Reflect

namespace core-js/web/timers.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

namespace core.Reflect

namespace core.Reflect {}

function apply

apply: (
    target: Function,
    thisArgument: any,
    argumentsList: ArrayLike<any>
) => any;

function construct

construct: (target: Function, argumentsList: ArrayLike<any>) => any;

function defineMetadata

defineMetadata: (
    metadataKey: any,
    metadataValue: any,
    target: Object,
    targetKey?: string | symbol
) => void;

Define a unique metadata entry on the target.

Parameter metadataKey

A key used to store and retrieve metadata.

Parameter metadataValue

A value that contains attached metadata.

Parameter target

The target object on which to define metadata.

Example 1

### Example

 class Example {
 }

 // constructor
 Reflect.defineMetadata("custom:annotation", options, Example);

 // decorator factory as metadata-producing annotation.
 function MyAnnotation(options): ClassDecorator {
     return target => Reflect.defineMetadata("custom:annotation", options, target);
 }

function defineProperty

defineProperty: (
    target: any,
    propertyKey: PropertyKey,
    attributes: PropertyDescriptor
) => boolean;

function deleteMetadata

deleteMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Deletes the metadata entry from the target object with the provided key.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata entry was found and deleted; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.deleteMetadata("custom:annotation", Example);

function deleteProperty

deleteProperty: (target: any, propertyKey: PropertyKey) => boolean;

function get

get: (target: any, propertyKey: PropertyKey, receiver?: any) => any;

function getMetadata

getMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object or its prototype chain.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadata("custom:annotation", Example);

function getMetadataKeys

getMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the metadata keys defined on the target object or its prototype chain.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getMetadataKeys(Example);

function getOwnMetadata

getOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => any;

Gets the metadata value for the provided metadata key on the target object.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
The metadata value for the metadata key if found; otherwise, undefined.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadata("custom:annotation", Example);

function getOwnMetadataKeys

getOwnMetadataKeys: (target: Object, targetKey?: string | symbol) => any[];

Gets the unique metadata keys defined on the target object.
Parameter target
The target object on which the metadata is defined.
Returns
An array of unique metadata keys.
Example 1
### Example
class Example { } // constructor result = Reflect.getOwnMetadataKeys(Example);

function getOwnPropertyDescriptor

getOwnPropertyDescriptor: (
    target: any,
    propertyKey: PropertyKey
) => PropertyDescriptor;

function getPrototypeOf

getPrototypeOf: (target: any) => any;

function has

has: (target: any, propertyKey: string | symbol) => boolean;

function hasMetadata

hasMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasMetadata("custom:annotation", Example);

function hasOwnMetadata

hasOwnMetadata: (
    metadataKey: any,
    target: Object,
    targetKey?: string | symbol
) => boolean;

Gets a value indicating whether the target object has the provided metadata key defined.
Parameter metadataKey
A key used to store and retrieve metadata.
Parameter target
The target object on which the metadata is defined.
Returns
true if the metadata key was defined on the target object; otherwise, false.
Example 1
### Example
class Example { } // constructor result = Reflect.hasOwnMetadata("custom:annotation", Example);

function isExtensible

isExtensible: (target: any) => boolean;

function metadata

metadata: (
    metadataKey: any,
    metadataValue: any
) => {
    (target: Function): void;
    (target: Object, targetKey: string | symbol): void;
};

A default metadata decorator factory that can be used on a class, class member, or parameter.

Parameter metadataKey

The key for the metadata entry.

Parameter metadataValue

The value for the metadata entry.

Returns

A decorator function.

Remarks

If metadataKey is already defined for the target and target key, the metadataValue for that key will be overwritten.

Example 1

### Example

 // constructor
 @Reflect.metadata(key, value)
 class Example {
 }

 // property (on constructor, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     static staticProperty;
 }

 // property (on prototype, TypeScript only)
 class Example {
     @Reflect.metadata(key, value)
     property;
 }

 // method (on constructor)
 class Example {
     @Reflect.metadata(key, value)
     static staticMethod() { }
 }

 // method (on prototype)
 class Example {
     @Reflect.metadata(key, value)
     method() { }
 }

function ownKeys

ownKeys: (target: any) => PropertyKey[];

function preventExtensions

preventExtensions: (target: any) => boolean;

function set

set: (
    target: any,
    propertyKey: PropertyKey,
    value: any,
    receiver?: any
) => boolean;

function setPrototypeOf

setPrototypeOf: (target: any, proto: any) => boolean;

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/core-js.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/core-js)

HTML

<a href="https://www.jsdocs.io/package/@types/core-js"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 16202 ms.
Missing or incorrect documentation? Open an issue for this package.