@types/core-js

  • Version 2.5.4
  • Published
  • 87.2 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

Functions

Namespaces

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[];