@angular-devkit/core

  • Version 12.2.11
  • Published
  • 436 kB
  • 6 dependencies
  • MIT license

Install

npm i @angular-devkit/core
yarn add @angular-devkit/core
pnpm add @angular-devkit/core

Overview

Angular DevKit - Core Utility Library

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable NormalizedRoot

const NormalizedRoot: String & { __PRIVATE_DEVKIT_PATH: void };
  • The root of a normalized path. {Path}

variable NormalizedSep

const NormalizedSep: String & { __PRIVATE_DEVKIT_PATH: void };
  • The Separator for normalized path. {Path}

variable path

const path: TemplateTag<Path>;

    Functions

    function asPosixPath

    asPosixPath: (path: Path) => PosixPath;

      function asWindowsPath

      asWindowsPath: (path: Path) => WindowsPath;

        function basename

        basename: (path: Path) => PathFragment;
        • Return the basename of the path, as a Path. See path.basename

        function clean

        clean: <T>(array: Array<T | undefined>) => Array<T>;
        • Deprecated

          Since v12.0, unused by the Angular tooling

        function deepCopy

        deepCopy: <T extends unknown>(value: T) => T;

          function dirname

          dirname: (path: Path) => Path;
          • Return the dirname of the path, as a Path. See path.dirname

          function extname

          extname: (path: Path) => string;

          function fragment

          fragment: (path: string) => PathFragment;

            function getSystemPath

            getSystemPath: (path: Path) => string;

              function isAbsolute

              isAbsolute: (p: Path) => boolean;
              • Returns true if a path is absolute.

              function isJsonArray

              isJsonArray: (value: JsonValue) => value is JsonArray;

                function isJsonObject

                isJsonObject: (value: JsonValue) => value is JsonObject;

                  function isPromise

                  isPromise: (obj: any) => obj is Promise<any>;
                  • Determine if the argument is shaped like a Promise

                  function join

                  join: (p1: Path, ...others: string[]) => Path;
                  • Join multiple paths together, and normalize the result. Accepts strings that will be normalized as well (but the original must be a path).

                  function mapObject

                  mapObject: <T, V>(
                  obj: { [k: string]: T },
                  mapper: (k: string, v: T) => V
                  ) => { [k: string]: V };
                  • Deprecated

                    Since v12.0, unused by the Angular tooling

                  function noCacheNormalize

                  noCacheNormalize: (path: string) => Path;
                  • The no cache version of the normalize() function. Used for benchmarking and testing.

                  function normalize

                  normalize: (path: string) => Path;
                  • Normalize a string into a Path. This is the only mean to get a Path type from a string that represents a system path. This method cache the results as real world paths tend to be duplicated often. Normalization includes: - Windows backslashes \\ are replaced with /. - Windows drivers are replaced with /X/, where X is the drive letter. - Absolute paths starts with /. - Multiple / are replaced by a single one. - Path segments . are removed. - Path segments .. are resolved. - If a path is absolute, having a .. at the start is invalid (and will throw).

                    Parameter path

                    The path to be normalized.

                  function parseJson

                  parseJson: (
                  input: string,
                  mode?: JsonParseMode,
                  options?: ParseJsonOptions
                  ) => JsonValue;
                  • Parse a JSON string into its value. This discards the AST and only returns the value itself.

                    If a path option is pass, it also absorbs JSON parsing errors and return a new error with the path in it. Useful for showing errors when parsing from a file.

                    Parameter input

                    The string to parse.

                    Parameter mode

                    The mode to parse the input with. .

                    Parameter options

                    Additional optinos for parsing.

                    Returns

                    {JsonValue} The value represented by the JSON string.

                    Deprecated

                    Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                  function parseJsonAst

                  parseJsonAst: (input: string, mode?: JsonParseMode) => JsonAstNode;
                  • Parse the JSON string and return its AST. The AST may be losing data (end comments are discarded for example, and space characters are not represented in the AST), but all values will have a single node in the AST (a 1-to-1 mapping).

                    Parameter input

                    The string to use.

                    Parameter mode

                    The mode to parse the input with. .

                    Returns

                    {JsonAstNode} The root node of the value of the AST.

                    Deprecated

                    Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                  function relative

                  relative: (from: Path, to: Path) => Path;
                  • Returns a path such that join(from, relative(from, to)) == to. Both paths must be absolute, otherwise it does not make much sense.

                  function resetNormalizeCache

                  resetNormalizeCache: () => void;
                  • Reset the cache. This is only useful for testing.

                  function resolve

                  resolve: (p1: Path, p2: Path) => Path;
                  • Returns a Path that is the resolution of p2, from p1. If p2 is absolute, it will return p2, otherwise will join both p1 and p2.

                  function split

                  split: (path: Path) => PathFragment[];
                  • Split a path into multiple path fragments. Each fragments except the last one will end with a path separator.

                    Parameter path

                    The path to split.

                    Returns

                    {Path[]} An array of path fragments.

                  function template

                  template: <T>(
                  content: string,
                  options?: TemplateOptions
                  ) => (input: T) => string;
                  • An equivalent of EJS templates, which is based on John Resig's tmpl implementation (http://ejohn.org/blog/javascript-micro-templating/) and Laura Doktorova's doT.js (https://github.com/olado/doT).

                    This version differs from lodash by removing support from ES6 quasi-literals, and making the code slightly simpler to follow. It also does not depend on any third party, which is nice.

                    Finally, it supports SourceMap, if you ever need to debug, which is super nice.

                    Parameter content

                    The template content.

                    Parameter options

                    Optional Options. See TemplateOptions for more description. {(input: T) => string} A function that accept an input object and returns the content of the template with the input applied.

                  function templateParser

                  templateParser: (sourceText: string, fileName: string) => TemplateAst;
                  • Given a source text (and a fileName), returns a TemplateAst.

                  Classes

                  class BaseException

                  class BaseException extends Error {}
                  • Copyright Google LLC All Rights Reserved.

                    Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                  constructor

                  constructor(message?: string);

                    class CircularDependencyFoundException

                    class CircularDependencyFoundException extends BaseException {}

                      constructor

                      constructor();

                        class ContentHasMutatedException

                        class ContentHasMutatedException extends BaseException {}

                          constructor

                          constructor(path: string);

                            class DependencyNotFoundException

                            class DependencyNotFoundException extends BaseException {}

                              constructor

                              constructor();

                                class FileAlreadyExistException

                                class FileAlreadyExistException extends BaseException {}

                                  constructor

                                  constructor(path: string);

                                    class FileDoesNotExistException

                                    class FileDoesNotExistException extends BaseException {}

                                      constructor

                                      constructor(path: string);

                                        class InvalidJsonCharacterException

                                        class InvalidJsonCharacterException extends JsonException {}
                                        • A character was invalid in this context.

                                          Deprecated

                                          Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                        constructor

                                        constructor(context: JsonParserContext);

                                          property character

                                          character: number;

                                            property invalidChar

                                            invalidChar: string;

                                              property line

                                              line: number;

                                                property offset

                                                offset: number;

                                                  class InvalidPathException

                                                  class InvalidPathException extends BaseException {}

                                                    constructor

                                                    constructor(path: string);

                                                      class InvalidUpdateRecordException

                                                      class InvalidUpdateRecordException extends BaseException {}

                                                        constructor

                                                        constructor();

                                                          class JsonException

                                                          class JsonException extends BaseException {}

                                                            class MergeConflictException

                                                            class MergeConflictException extends BaseException {}

                                                              constructor

                                                              constructor(path: string);

                                                                class PartiallyOrderedSet

                                                                class PartiallyOrderedSet<T> implements Set<T> {}

                                                                  property [Symbol.toStringTag]

                                                                  readonly [Symbol.toStringTag]: string;

                                                                    property size

                                                                    readonly size: number;

                                                                      method [Symbol.iterator]

                                                                      [Symbol.iterator]: () => Generator<T, void, unknown>;

                                                                        method add

                                                                        add: (item: T, deps?: Set<T> | T[]) => this;

                                                                          method clear

                                                                          clear: () => void;

                                                                            method delete

                                                                            delete: (item: T) => boolean;

                                                                              method entries

                                                                              entries: () => IterableIterator<[T, T]>;
                                                                              • Returns an iterable of [v,v] pairs for every value v in the set.

                                                                              method forEach

                                                                              forEach: (
                                                                              callbackfn: (value: T, value2: T, set: PartiallyOrderedSet<T>) => void,
                                                                              thisArg?: any
                                                                              ) => void;

                                                                                method has

                                                                                has: (item: T) => boolean;

                                                                                  method keys

                                                                                  keys: () => IterableIterator<T>;
                                                                                  • Despite its name, returns an iterable of the values in the set,

                                                                                  method values

                                                                                  values: () => IterableIterator<T>;
                                                                                  • Returns an iterable of values in the set.

                                                                                  class PathCannotBeFragmentException

                                                                                  class PathCannotBeFragmentException extends BaseException {}

                                                                                    constructor

                                                                                    constructor(path: string);

                                                                                      class PathIsDirectoryException

                                                                                      class PathIsDirectoryException extends BaseException {}

                                                                                        constructor

                                                                                        constructor(path: string);

                                                                                          class PathIsFileException

                                                                                          class PathIsFileException extends BaseException {}

                                                                                            constructor

                                                                                            constructor(path: string);

                                                                                              class PathMustBeAbsoluteException

                                                                                              class PathMustBeAbsoluteException extends BaseException {}

                                                                                                constructor

                                                                                                constructor(path: string);

                                                                                                  class PathSpecificJsonException

                                                                                                  class PathSpecificJsonException extends JsonException {}
                                                                                                  • An error happened within a file.

                                                                                                    Deprecated

                                                                                                    Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                  constructor

                                                                                                  constructor(path: string, exception: JsonException);

                                                                                                    property exception

                                                                                                    exception: JsonException;

                                                                                                      property path

                                                                                                      path: string;

                                                                                                        class PriorityQueue

                                                                                                        class PriorityQueue<T> {}
                                                                                                        • Naive priority queue; not intended for large datasets

                                                                                                        constructor

                                                                                                        constructor(_comparator: (x: T, y: T) => number);

                                                                                                          property size

                                                                                                          readonly size: number;

                                                                                                            method clear

                                                                                                            clear: () => void;

                                                                                                              method peek

                                                                                                              peek: () => T | undefined;

                                                                                                                method pop

                                                                                                                pop: () => T | undefined;

                                                                                                                  method push

                                                                                                                  push: (item: T) => void;

                                                                                                                    method toArray

                                                                                                                    toArray: () => Array<T>;

                                                                                                                      class UnexpectedEndOfInputException

                                                                                                                      class UnexpectedEndOfInputException extends JsonException {}
                                                                                                                      • More input was expected, but we reached the end of the stream.

                                                                                                                        Deprecated

                                                                                                                        Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                      constructor

                                                                                                                      constructor(_context: JsonParserContext);

                                                                                                                        class UnimplementedException

                                                                                                                        class UnimplementedException extends BaseException {}

                                                                                                                          constructor

                                                                                                                          constructor();

                                                                                                                            class UnknownException

                                                                                                                            class UnknownException extends BaseException {}

                                                                                                                              constructor

                                                                                                                              constructor(message: string);

                                                                                                                                class UnsupportedPlatformException

                                                                                                                                class UnsupportedPlatformException extends BaseException {}

                                                                                                                                  constructor

                                                                                                                                  constructor();

                                                                                                                                    Interfaces

                                                                                                                                    interface DeepReadonlyArray

                                                                                                                                    interface DeepReadonlyArray<T> extends Array<DeepReadonly<T>> {}

                                                                                                                                      interface JsonArray

                                                                                                                                      interface JsonArray extends Array<JsonValue> {}

                                                                                                                                        interface JsonAstArray

                                                                                                                                        interface JsonAstArray extends JsonAstNodeBase {}

                                                                                                                                          property elements

                                                                                                                                          readonly elements: JsonAstNode[];

                                                                                                                                            property kind

                                                                                                                                            readonly kind: 'array';

                                                                                                                                              property value

                                                                                                                                              readonly value: JsonArray;

                                                                                                                                                interface JsonAstComment

                                                                                                                                                interface JsonAstComment extends JsonAstNodeBase {}

                                                                                                                                                  property content

                                                                                                                                                  readonly content: string;

                                                                                                                                                    property kind

                                                                                                                                                    readonly kind: 'comment';

                                                                                                                                                      interface JsonAstConstantFalse

                                                                                                                                                      interface JsonAstConstantFalse extends JsonAstNodeBase {}

                                                                                                                                                        property kind

                                                                                                                                                        readonly kind: 'false';

                                                                                                                                                          property value

                                                                                                                                                          readonly value: false;

                                                                                                                                                            interface JsonAstConstantNull

                                                                                                                                                            interface JsonAstConstantNull extends JsonAstNodeBase {}

                                                                                                                                                              property kind

                                                                                                                                                              readonly kind: 'null';

                                                                                                                                                                property value

                                                                                                                                                                readonly value: null;

                                                                                                                                                                  interface JsonAstConstantTrue

                                                                                                                                                                  interface JsonAstConstantTrue extends JsonAstNodeBase {}

                                                                                                                                                                    property kind

                                                                                                                                                                    readonly kind: 'true';

                                                                                                                                                                      property value

                                                                                                                                                                      readonly value: true;

                                                                                                                                                                        interface JsonAstIdentifier

                                                                                                                                                                        interface JsonAstIdentifier extends JsonAstNodeBase {}

                                                                                                                                                                          property kind

                                                                                                                                                                          readonly kind: 'identifier';

                                                                                                                                                                            property value

                                                                                                                                                                            readonly value: string;

                                                                                                                                                                              interface JsonAstKeyValue

                                                                                                                                                                              interface JsonAstKeyValue extends JsonAstNodeBase {}

                                                                                                                                                                                property key

                                                                                                                                                                                readonly key: JsonAstString | JsonAstIdentifier;

                                                                                                                                                                                  property kind

                                                                                                                                                                                  readonly kind: 'keyvalue';

                                                                                                                                                                                    property value

                                                                                                                                                                                    readonly value: JsonAstNode;

                                                                                                                                                                                      interface JsonAstMultilineComment

                                                                                                                                                                                      interface JsonAstMultilineComment extends JsonAstNodeBase {}

                                                                                                                                                                                        property content

                                                                                                                                                                                        readonly content: string;

                                                                                                                                                                                          property kind

                                                                                                                                                                                          readonly kind: 'multicomment';

                                                                                                                                                                                            interface JsonAstNodeBase

                                                                                                                                                                                            interface JsonAstNodeBase {}

                                                                                                                                                                                              property comments

                                                                                                                                                                                              readonly comments?: (JsonAstComment | JsonAstMultilineComment)[];

                                                                                                                                                                                                property end

                                                                                                                                                                                                readonly end: Position;

                                                                                                                                                                                                  property start

                                                                                                                                                                                                  readonly start: Position;

                                                                                                                                                                                                    property text

                                                                                                                                                                                                    readonly text: string;

                                                                                                                                                                                                      interface JsonAstNumber

                                                                                                                                                                                                      interface JsonAstNumber extends JsonAstNodeBase {}

                                                                                                                                                                                                        property kind

                                                                                                                                                                                                        readonly kind: 'number';

                                                                                                                                                                                                          property value

                                                                                                                                                                                                          readonly value: number;

                                                                                                                                                                                                            interface JsonAstObject

                                                                                                                                                                                                            interface JsonAstObject extends JsonAstNodeBase {}

                                                                                                                                                                                                              property kind

                                                                                                                                                                                                              readonly kind: 'object';

                                                                                                                                                                                                                property properties

                                                                                                                                                                                                                readonly properties: JsonAstKeyValue[];

                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                  readonly value: JsonObject;

                                                                                                                                                                                                                    interface JsonAstString

                                                                                                                                                                                                                    interface JsonAstString extends JsonAstNodeBase {}

                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                      readonly kind: 'string';

                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                        readonly value: string;

                                                                                                                                                                                                                          interface JsonObject

                                                                                                                                                                                                                          interface JsonObject {}

                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                            [prop: string]: JsonValue;

                                                                                                                                                                                                                              interface JsonParserContext

                                                                                                                                                                                                                              interface JsonParserContext {}
                                                                                                                                                                                                                              • Context passed around the parser with information about where we currently are in the parse.

                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                              property mode

                                                                                                                                                                                                                              readonly mode: JsonParseMode;

                                                                                                                                                                                                                                property original

                                                                                                                                                                                                                                readonly original: string;

                                                                                                                                                                                                                                  property position

                                                                                                                                                                                                                                  position: Position;

                                                                                                                                                                                                                                    property previous

                                                                                                                                                                                                                                    previous: Position;

                                                                                                                                                                                                                                      interface ParseJsonOptions

                                                                                                                                                                                                                                      interface ParseJsonOptions {}
                                                                                                                                                                                                                                      • Options for the parseJson() function.

                                                                                                                                                                                                                                        Deprecated

                                                                                                                                                                                                                                        Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                      path?: string;
                                                                                                                                                                                                                                      • If omitted, will only emit errors related to the content of the JSON. If specified, any JSON errors will also include the path of the file that caused the error.

                                                                                                                                                                                                                                      interface Position

                                                                                                                                                                                                                                      interface Position {}
                                                                                                                                                                                                                                      • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                        Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                      property character

                                                                                                                                                                                                                                      readonly character: number;

                                                                                                                                                                                                                                        property line

                                                                                                                                                                                                                                        readonly line: number;

                                                                                                                                                                                                                                          property offset

                                                                                                                                                                                                                                          readonly offset: number;

                                                                                                                                                                                                                                            interface TemplateAst

                                                                                                                                                                                                                                            interface TemplateAst {}
                                                                                                                                                                                                                                            • A simple AST for templates. There's only one level of AST nodes, but it's still useful to have the information you're looking for.

                                                                                                                                                                                                                                            property children

                                                                                                                                                                                                                                            children: TemplateAstNode[];

                                                                                                                                                                                                                                              property content

                                                                                                                                                                                                                                              content: string;

                                                                                                                                                                                                                                                property fileName

                                                                                                                                                                                                                                                fileName: string;

                                                                                                                                                                                                                                                  interface TemplateAstBase

                                                                                                                                                                                                                                                  interface TemplateAstBase {}
                                                                                                                                                                                                                                                  • The base, which contains positions.

                                                                                                                                                                                                                                                  property end

                                                                                                                                                                                                                                                  end: Position;

                                                                                                                                                                                                                                                    property start

                                                                                                                                                                                                                                                    start: Position;

                                                                                                                                                                                                                                                      interface TemplateAstComment

                                                                                                                                                                                                                                                      interface TemplateAstComment extends TemplateAstBase {}
                                                                                                                                                                                                                                                      • A comment node.

                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                      kind: 'comment';

                                                                                                                                                                                                                                                        property text

                                                                                                                                                                                                                                                        text: string;

                                                                                                                                                                                                                                                          interface TemplateAstContent

                                                                                                                                                                                                                                                          interface TemplateAstContent extends TemplateAstBase {}
                                                                                                                                                                                                                                                          • A static content node.

                                                                                                                                                                                                                                                          property content

                                                                                                                                                                                                                                                          content: string;

                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                            kind: 'content';

                                                                                                                                                                                                                                                              interface TemplateAstEscape

                                                                                                                                                                                                                                                              interface TemplateAstEscape extends TemplateAstBase {}
                                                                                                                                                                                                                                                              • An escape node, which is the code between <%- ... %>.

                                                                                                                                                                                                                                                              property expression

                                                                                                                                                                                                                                                              expression: string;

                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                kind: 'escape';

                                                                                                                                                                                                                                                                  interface TemplateAstEvaluate

                                                                                                                                                                                                                                                                  interface TemplateAstEvaluate extends TemplateAstBase {}
                                                                                                                                                                                                                                                                  • An evaluate node, which is the code between <% ... %>.

                                                                                                                                                                                                                                                                  property expression

                                                                                                                                                                                                                                                                  expression: string;

                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                    kind: 'evaluate';

                                                                                                                                                                                                                                                                      interface TemplateAstInterpolate

                                                                                                                                                                                                                                                                      interface TemplateAstInterpolate extends TemplateAstBase {}
                                                                                                                                                                                                                                                                      • An interpolation node, which is the code between <%= ... %>.

                                                                                                                                                                                                                                                                      property expression

                                                                                                                                                                                                                                                                      expression: string;

                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                        kind: 'interpolate';

                                                                                                                                                                                                                                                                          interface TemplateOptions

                                                                                                                                                                                                                                                                          interface TemplateOptions {}

                                                                                                                                                                                                                                                                            property fileName

                                                                                                                                                                                                                                                                            fileName?: string;

                                                                                                                                                                                                                                                                              property module

                                                                                                                                                                                                                                                                              module?:
                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                              exports: {};
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                property sourceMap

                                                                                                                                                                                                                                                                                sourceMap?: boolean;

                                                                                                                                                                                                                                                                                  property sourceRoot

                                                                                                                                                                                                                                                                                  sourceRoot?: string;

                                                                                                                                                                                                                                                                                    property sourceURL

                                                                                                                                                                                                                                                                                    sourceURL?: string;

                                                                                                                                                                                                                                                                                      Enums

                                                                                                                                                                                                                                                                                      enum JsonParseMode

                                                                                                                                                                                                                                                                                      enum JsonParseMode {
                                                                                                                                                                                                                                                                                      Strict = 0,
                                                                                                                                                                                                                                                                                      CommentsAllowed = 1,
                                                                                                                                                                                                                                                                                      SingleQuotesAllowed = 2,
                                                                                                                                                                                                                                                                                      IdentifierKeyNamesAllowed = 4,
                                                                                                                                                                                                                                                                                      TrailingCommasAllowed = 8,
                                                                                                                                                                                                                                                                                      HexadecimalNumberAllowed = 16,
                                                                                                                                                                                                                                                                                      MultiLineStringAllowed = 32,
                                                                                                                                                                                                                                                                                      LaxNumberParsingAllowed = 64,
                                                                                                                                                                                                                                                                                      NumberConstantsAllowed = 128,
                                                                                                                                                                                                                                                                                      Default = 0,
                                                                                                                                                                                                                                                                                      Loose = 255,
                                                                                                                                                                                                                                                                                      Json = 0,
                                                                                                                                                                                                                                                                                      Json5 = 255,
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      • The Parse mode used for parsing the JSON string.

                                                                                                                                                                                                                                                                                      member CommentsAllowed

                                                                                                                                                                                                                                                                                      CommentsAllowed = 1

                                                                                                                                                                                                                                                                                        member Default

                                                                                                                                                                                                                                                                                        Default = 0

                                                                                                                                                                                                                                                                                          member HexadecimalNumberAllowed

                                                                                                                                                                                                                                                                                          HexadecimalNumberAllowed = 16

                                                                                                                                                                                                                                                                                            member IdentifierKeyNamesAllowed

                                                                                                                                                                                                                                                                                            IdentifierKeyNamesAllowed = 4

                                                                                                                                                                                                                                                                                              member Json

                                                                                                                                                                                                                                                                                              Json = 0

                                                                                                                                                                                                                                                                                                member Json5

                                                                                                                                                                                                                                                                                                Json5 = 255

                                                                                                                                                                                                                                                                                                  member LaxNumberParsingAllowed

                                                                                                                                                                                                                                                                                                  LaxNumberParsingAllowed = 64

                                                                                                                                                                                                                                                                                                    member Loose

                                                                                                                                                                                                                                                                                                    Loose = 255

                                                                                                                                                                                                                                                                                                      member MultiLineStringAllowed

                                                                                                                                                                                                                                                                                                      MultiLineStringAllowed = 32

                                                                                                                                                                                                                                                                                                        member NumberConstantsAllowed

                                                                                                                                                                                                                                                                                                        NumberConstantsAllowed = 128

                                                                                                                                                                                                                                                                                                          member SingleQuotesAllowed

                                                                                                                                                                                                                                                                                                          SingleQuotesAllowed = 2

                                                                                                                                                                                                                                                                                                            member Strict

                                                                                                                                                                                                                                                                                                            Strict = 0

                                                                                                                                                                                                                                                                                                              member TrailingCommasAllowed

                                                                                                                                                                                                                                                                                                              TrailingCommasAllowed = 8

                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                type DeepReadonly

                                                                                                                                                                                                                                                                                                                type DeepReadonly<T> = T extends (infer R)[]
                                                                                                                                                                                                                                                                                                                ? DeepReadonlyArray<R>
                                                                                                                                                                                                                                                                                                                : T extends Function
                                                                                                                                                                                                                                                                                                                ? T
                                                                                                                                                                                                                                                                                                                : T extends object
                                                                                                                                                                                                                                                                                                                ? DeepReadonlyObject<T>
                                                                                                                                                                                                                                                                                                                : T;

                                                                                                                                                                                                                                                                                                                  type DeepReadonlyObject

                                                                                                                                                                                                                                                                                                                  type DeepReadonlyObject<T> = {
                                                                                                                                                                                                                                                                                                                  readonly [P in keyof T]: DeepReadonly<T[P]>;
                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                    type JsonAstNode

                                                                                                                                                                                                                                                                                                                    type JsonAstNode =
                                                                                                                                                                                                                                                                                                                    | JsonAstNumber
                                                                                                                                                                                                                                                                                                                    | JsonAstString
                                                                                                                                                                                                                                                                                                                    | JsonAstIdentifier
                                                                                                                                                                                                                                                                                                                    | JsonAstArray
                                                                                                                                                                                                                                                                                                                    | JsonAstObject
                                                                                                                                                                                                                                                                                                                    | JsonAstConstantFalse
                                                                                                                                                                                                                                                                                                                    | JsonAstConstantNull
                                                                                                                                                                                                                                                                                                                    | JsonAstConstantTrue;

                                                                                                                                                                                                                                                                                                                      type JsonValue

                                                                                                                                                                                                                                                                                                                      type JsonValue = JsonAstNode['value'];

                                                                                                                                                                                                                                                                                                                        type Path

                                                                                                                                                                                                                                                                                                                        type Path = string & {
                                                                                                                                                                                                                                                                                                                        __PRIVATE_DEVKIT_PATH: void;
                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                        • A Path recognized by most methods in the DevKit.

                                                                                                                                                                                                                                                                                                                        type PathFragment

                                                                                                                                                                                                                                                                                                                        type PathFragment = Path & {
                                                                                                                                                                                                                                                                                                                        __PRIVATE_DEVKIT_PATH_FRAGMENT: void;
                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                        • A Path fragment (file or directory name) recognized by most methods in the DevKit.

                                                                                                                                                                                                                                                                                                                        type PosixPath

                                                                                                                                                                                                                                                                                                                        type PosixPath = string & {
                                                                                                                                                                                                                                                                                                                        __PRIVATE_DEVKIT_POSIX_PATH: void;
                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                          type Readwrite

                                                                                                                                                                                                                                                                                                                          type Readwrite<T> = {
                                                                                                                                                                                                                                                                                                                          -readonly [P in keyof T]: T[P];
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            type TemplateAstNode

                                                                                                                                                                                                                                                                                                                            type TemplateAstNode =
                                                                                                                                                                                                                                                                                                                            | TemplateAstContent
                                                                                                                                                                                                                                                                                                                            | TemplateAstEvaluate
                                                                                                                                                                                                                                                                                                                            | TemplateAstComment
                                                                                                                                                                                                                                                                                                                            | TemplateAstEscape
                                                                                                                                                                                                                                                                                                                            | TemplateAstInterpolate;

                                                                                                                                                                                                                                                                                                                              type WindowsPath

                                                                                                                                                                                                                                                                                                                              type WindowsPath = string & {
                                                                                                                                                                                                                                                                                                                              __PRIVATE_DEVKIT_WINDOWS_PATH: void;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                Namespaces

                                                                                                                                                                                                                                                                                                                                namespace analytics

                                                                                                                                                                                                                                                                                                                                module 'src/analytics/index.d.ts' {}
                                                                                                                                                                                                                                                                                                                                • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                  Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                variable NgCliAnalyticsDimensionsFlagInfo

                                                                                                                                                                                                                                                                                                                                const NgCliAnalyticsDimensionsFlagInfo: { [name: string]: [string, string] };

                                                                                                                                                                                                                                                                                                                                  variable NgCliAnalyticsMetricsFlagInfo

                                                                                                                                                                                                                                                                                                                                  const NgCliAnalyticsMetricsFlagInfo: { [name: string]: [string, string] };

                                                                                                                                                                                                                                                                                                                                    class AnalyticsReporter

                                                                                                                                                                                                                                                                                                                                    class AnalyticsReporter {}

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(_analytics: Analytics);

                                                                                                                                                                                                                                                                                                                                        method report

                                                                                                                                                                                                                                                                                                                                        report: (report: AnalyticsReport) => void;

                                                                                                                                                                                                                                                                                                                                          class ForwardingAnalytics

                                                                                                                                                                                                                                                                                                                                          class ForwardingAnalytics implements Analytics {}
                                                                                                                                                                                                                                                                                                                                          • A class that follows the Analytics interface and forwards analytic reports (JavaScript objects). AnalyticsReporter is the counterpart which takes analytic reports and report them to another Analytics interface.

                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                          constructor(_fn: AnalyticsForwarderFn);

                                                                                                                                                                                                                                                                                                                                            method event

                                                                                                                                                                                                                                                                                                                                            event: (category: string, action: string, options?: EventOptions) => void;

                                                                                                                                                                                                                                                                                                                                              method flush

                                                                                                                                                                                                                                                                                                                                              flush: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                method pageview

                                                                                                                                                                                                                                                                                                                                                pageview: (path: string, options?: PageviewOptions) => void;

                                                                                                                                                                                                                                                                                                                                                  method screenview

                                                                                                                                                                                                                                                                                                                                                  screenview: (
                                                                                                                                                                                                                                                                                                                                                  screenName: string,
                                                                                                                                                                                                                                                                                                                                                  appName: string,
                                                                                                                                                                                                                                                                                                                                                  options?: ScreenviewOptions
                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                    method timing

                                                                                                                                                                                                                                                                                                                                                    timing: (
                                                                                                                                                                                                                                                                                                                                                    category: string,
                                                                                                                                                                                                                                                                                                                                                    variable: string,
                                                                                                                                                                                                                                                                                                                                                    time: string | number,
                                                                                                                                                                                                                                                                                                                                                    options?: TimingOptions
                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                      class LoggingAnalytics

                                                                                                                                                                                                                                                                                                                                                      class LoggingAnalytics implements Analytics {}
                                                                                                                                                                                                                                                                                                                                                      • Analytics implementation that logs analytics events to a logger. This should be used for debugging mainly.

                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                      constructor(_logger: Logger);

                                                                                                                                                                                                                                                                                                                                                        method event

                                                                                                                                                                                                                                                                                                                                                        event: (category: string, action: string, options?: EventOptions) => void;

                                                                                                                                                                                                                                                                                                                                                          method flush

                                                                                                                                                                                                                                                                                                                                                          flush: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                            method pageview

                                                                                                                                                                                                                                                                                                                                                            pageview: (path: string, options?: PageviewOptions) => void;

                                                                                                                                                                                                                                                                                                                                                              method screenview

                                                                                                                                                                                                                                                                                                                                                              screenview: (
                                                                                                                                                                                                                                                                                                                                                              screenName: string,
                                                                                                                                                                                                                                                                                                                                                              appName: string,
                                                                                                                                                                                                                                                                                                                                                              options?: ScreenviewOptions
                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                method timing

                                                                                                                                                                                                                                                                                                                                                                timing: (
                                                                                                                                                                                                                                                                                                                                                                category: string,
                                                                                                                                                                                                                                                                                                                                                                variable: string,
                                                                                                                                                                                                                                                                                                                                                                time: string | number,
                                                                                                                                                                                                                                                                                                                                                                options?: TimingOptions
                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                  class MultiAnalytics

                                                                                                                                                                                                                                                                                                                                                                  class MultiAnalytics implements Analytics {}
                                                                                                                                                                                                                                                                                                                                                                  • Analytics implementation that reports to multiple analytics backend.

                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                  constructor(_backends?: Analytics[]);

                                                                                                                                                                                                                                                                                                                                                                    method event

                                                                                                                                                                                                                                                                                                                                                                    event: (category: string, action: string, options?: EventOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                      method flush

                                                                                                                                                                                                                                                                                                                                                                      flush: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                        method pageview

                                                                                                                                                                                                                                                                                                                                                                        pageview: (path: string, options?: PageviewOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                          method push

                                                                                                                                                                                                                                                                                                                                                                          push: (...backend: Analytics[]) => void;

                                                                                                                                                                                                                                                                                                                                                                            method screenview

                                                                                                                                                                                                                                                                                                                                                                            screenview: (
                                                                                                                                                                                                                                                                                                                                                                            screenName: string,
                                                                                                                                                                                                                                                                                                                                                                            appName: string,
                                                                                                                                                                                                                                                                                                                                                                            options?: ScreenviewOptions
                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                              method timing

                                                                                                                                                                                                                                                                                                                                                                              timing: (
                                                                                                                                                                                                                                                                                                                                                                              category: string,
                                                                                                                                                                                                                                                                                                                                                                              variable: string,
                                                                                                                                                                                                                                                                                                                                                                              time: string | number,
                                                                                                                                                                                                                                                                                                                                                                              options?: TimingOptions
                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                class NoopAnalytics

                                                                                                                                                                                                                                                                                                                                                                                class NoopAnalytics implements Analytics {}
                                                                                                                                                                                                                                                                                                                                                                                • Analytics implementation that does nothing.

                                                                                                                                                                                                                                                                                                                                                                                method event

                                                                                                                                                                                                                                                                                                                                                                                event: () => void;

                                                                                                                                                                                                                                                                                                                                                                                  method flush

                                                                                                                                                                                                                                                                                                                                                                                  flush: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                    method pageview

                                                                                                                                                                                                                                                                                                                                                                                    pageview: () => void;

                                                                                                                                                                                                                                                                                                                                                                                      method screenview

                                                                                                                                                                                                                                                                                                                                                                                      screenview: () => void;

                                                                                                                                                                                                                                                                                                                                                                                        method timing

                                                                                                                                                                                                                                                                                                                                                                                        timing: () => void;

                                                                                                                                                                                                                                                                                                                                                                                          interface Analytics

                                                                                                                                                                                                                                                                                                                                                                                          interface Analytics {}
                                                                                                                                                                                                                                                                                                                                                                                          • Interface for managing analytics. This is highly platform dependent, and mostly matches Google Analytics. The reason the interface is here is to remove the dependency to an implementation from most other places.

                                                                                                                                                                                                                                                                                                                                                                                            The methods exported from this interface more or less match those needed by us in the universal analytics package, see https://unpkg.com/@types/universal-analytics@0.4.2/index.d.ts for typings. We mostly named arguments to make it easier to follow, but didn't change or add any semantics to those methods. They're mapping GA and u-a one for one.

                                                                                                                                                                                                                                                                                                                                                                                            The Angular CLI (or any other kind of backend) should forward it to some compatible backend.

                                                                                                                                                                                                                                                                                                                                                                                          method event

                                                                                                                                                                                                                                                                                                                                                                                          event: (category: string, action: string, options?: EventOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                            method flush

                                                                                                                                                                                                                                                                                                                                                                                            flush: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                              method pageview

                                                                                                                                                                                                                                                                                                                                                                                              pageview: (path: string, options?: PageviewOptions) => void;

                                                                                                                                                                                                                                                                                                                                                                                                method screenview

                                                                                                                                                                                                                                                                                                                                                                                                screenview: (
                                                                                                                                                                                                                                                                                                                                                                                                screenName: string,
                                                                                                                                                                                                                                                                                                                                                                                                appName: string,
                                                                                                                                                                                                                                                                                                                                                                                                options?: ScreenviewOptions
                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method timing

                                                                                                                                                                                                                                                                                                                                                                                                  timing: (
                                                                                                                                                                                                                                                                                                                                                                                                  category: string,
                                                                                                                                                                                                                                                                                                                                                                                                  variable: string,
                                                                                                                                                                                                                                                                                                                                                                                                  time: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: TimingOptions
                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    interface AnalyticsReportBase

                                                                                                                                                                                                                                                                                                                                                                                                    interface AnalyticsReportBase extends JsonObject {}

                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                      kind: AnalyticsReportKind;

                                                                                                                                                                                                                                                                                                                                                                                                        interface AnalyticsReportEvent

                                                                                                                                                                                                                                                                                                                                                                                                        interface AnalyticsReportEvent extends AnalyticsReportBase {}

                                                                                                                                                                                                                                                                                                                                                                                                          property action

                                                                                                                                                                                                                                                                                                                                                                                                          action: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property category

                                                                                                                                                                                                                                                                                                                                                                                                            category: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                              kind: AnalyticsReportKind.Event;

                                                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                                                options: JsonObject & EventOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface AnalyticsReportPageview

                                                                                                                                                                                                                                                                                                                                                                                                                  interface AnalyticsReportPageview extends AnalyticsReportBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                    kind: AnalyticsReportKind.Pageview;

                                                                                                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                                                                                                      options: JsonObject & PageviewOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                                                                        path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          interface AnalyticsReportScreenview

                                                                                                                                                                                                                                                                                                                                                                                                                          interface AnalyticsReportScreenview extends AnalyticsReportBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property appName

                                                                                                                                                                                                                                                                                                                                                                                                                            appName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                              kind: AnalyticsReportKind.Screenview;

                                                                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                                                                options: JsonObject & ScreenviewOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property screenName

                                                                                                                                                                                                                                                                                                                                                                                                                                  screenName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AnalyticsReportTiming

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AnalyticsReportTiming extends AnalyticsReportBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property category

                                                                                                                                                                                                                                                                                                                                                                                                                                      category: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                        kind: AnalyticsReportKind.Timing;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                          options: JsonObject & TimingOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property time

                                                                                                                                                                                                                                                                                                                                                                                                                                            time: string | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property variable

                                                                                                                                                                                                                                                                                                                                                                                                                                              variable: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomDimensionsAndMetricsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CustomDimensionsAndMetricsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                                                                                                                                property dimensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                dimensions?: (boolean | number | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metrics

                                                                                                                                                                                                                                                                                                                                                                                                                                                  metrics?: (boolean | number | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EventOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EventOptions extends CustomDimensionsAndMetricsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                      label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                        value?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PageviewOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PageviewOptions extends CustomDimensionsAndMetricsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hostname

                                                                                                                                                                                                                                                                                                                                                                                                                                                            hostname?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                              title?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ScreenviewOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ScreenviewOptions extends CustomDimensionsAndMetricsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property appId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  appId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property appInstallerId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    appInstallerId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property appVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      appVersion?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TimingOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TimingOptions extends CustomDimensionsAndMetricsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum AnalyticsReportKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum AnalyticsReportKind {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Event = 'event',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Screenview = 'screenview',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pageview = 'pageview',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Timing = 'timing',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Event = 'event'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Pageview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pageview = 'pageview'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Screenview

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Screenview = 'screenview'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Timing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Timing = 'timing'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum NgCliAnalyticsDimensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum NgCliAnalyticsDimensions {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CpuCount = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CpuSpeed = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RamInGigabytes = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NodeVersion = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NgAddCollection = 6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NgIvyEnabled = 8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BuildErrors = 20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • MAKE SURE TO KEEP THIS IN SYNC WITH THE TABLE AND CONTENT IN /docs/design/analytics.md. WE LIST THOSE DIMENSIONS (AND MORE).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        These cannot be in their respective schema.json file because we either change the type (e.g. --buildEventLog is string, but we want to know the usage of it, not its value), or some validation needs to be done (we cannot record ng add --collection if it's not marked as allowed).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member BuildErrors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BuildErrors = 20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member CpuCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CpuCount = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member CpuSpeed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CpuSpeed = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member NgAddCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NgAddCollection = 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member NgIvyEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NgIvyEnabled = 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member NodeVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NodeVersion = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member RamInGigabytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RamInGigabytes = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum NgCliAnalyticsMetrics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum NgCliAnalyticsMetrics {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NgComponentCount = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UNUSED_2 = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UNUSED_3 = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UNUSED_4 = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BuildTime = 5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NgOnInitCount = 6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    InitialChunkSize = 7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TotalChunkCount = 8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TotalChunkSize = 9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LazyChunkCount = 10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LazyChunkSize = 11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AssetCount = 12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AssetSize = 13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PolyfillSize = 14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CssSize = 15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member AssetCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AssetCount = 12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member AssetSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AssetSize = 13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member BuildTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BuildTime = 5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member CssSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CssSize = 15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member InitialChunkSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InitialChunkSize = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member LazyChunkCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                LazyChunkCount = 10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member LazyChunkSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LazyChunkSize = 11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member NgComponentCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NgComponentCount = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member NgOnInitCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NgOnInitCount = 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member PolyfillSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PolyfillSize = 14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member TotalChunkCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TotalChunkCount = 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member TotalChunkSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TotalChunkSize = 9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member UNUSED_2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UNUSED_2 = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member UNUSED_3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UNUSED_3 = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member UNUSED_4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UNUSED_4 = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AnalyticsForwarderFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AnalyticsForwarderFn = (report: JsonObject & AnalyticsReport) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A function that can forward analytics along some stream. AnalyticsReport is already a JsonObject descendant, but we force it here so the user knows it's safe to serialize.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AnalyticsReport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AnalyticsReport =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AnalyticsReportEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AnalyticsReportScreenview
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AnalyticsReportPageview
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AnalyticsReportTiming;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace experimental

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'src/experimental.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace jobs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'src/experimental/jobs/index.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function createDispatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createDispatcher: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends string | number | boolean | JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Partial<Readwrite<JobDescription>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => JobDispatcher<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • OnReady a dispatcher that can dispatch to a sub job, depending on conditions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function createJobFactory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createJobFactory: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends string | number | boolean | JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loader: () => Promise<JobHandler<A, I, O>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Partial<JobDescription>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => JobHandler<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Lazily create a job using a function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter loader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A factory function that returns a promise/observable of a JobHandler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Same options as createJob.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function createJobHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createJobHandler: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends string | number | boolean | JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fn: SimpleJobHandlerFn<A, I, O>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: Partial<JobDescription>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => JobHandler<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Make a simple job handler that sets start and end from a function that's synchronous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The function to create a handler for.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An optional set of properties to set on the handler. Some fields might be required by registry or schedulers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function createLoggerJob

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createLoggerJob: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends string | number | boolean | JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      job: JobHandler<A, I, O>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      logger: LoggerApi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => JobHandler<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Creates a job that logs out input/output messages of another Job. The messages are still propagated to the other job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isJobHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isJobHandler: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends string | number | boolean | JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => value is JobHandler<A, I, O>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ChannelAlreadyExistException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ChannelAlreadyExistException extends BaseException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(name: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class FallbackRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class FallbackRegistry<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MinimumArgumentValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MinimumInputValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MinimumOutputValueT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > implements
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A simple job registry that keep a map of JobName => JobHandler internally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _fallbacks?: Registry<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MinimumArgumentValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MinimumInputValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MinimumOutputValueT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addFallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addFallback: (registry: Registry) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                get: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A extends MinimumArgumentValueT = MinimumArgumentValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                I extends MinimumInputValueT = MinimumInputValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                O extends MinimumOutputValueT = MinimumOutputValueT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: JobName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JobArgumentSchemaValidationError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JobArgumentSchemaValidationError extends schema.SchemaValidationException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(errors?: any[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class JobDoesNotExistException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class JobDoesNotExistException extends BaseException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(name: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class JobInboundMessageSchemaValidationError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class JobInboundMessageSchemaValidationError extends schema.SchemaValidationException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(errors?: any[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class JobNameAlreadyRegisteredException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class JobNameAlreadyRegisteredException extends BaseException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(name: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JobOutputSchemaValidationError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JobOutputSchemaValidationError extends schema.SchemaValidationException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(errors?: any[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SimpleJobRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SimpleJobRegistry<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumArgumentValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumInputValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumOutputValueT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > implements
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A simple job registry that keep a map of JobName => JobHandler internally.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      get: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends MinimumArgumentValueT = MinimumArgumentValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends MinimumInputValueT = MinimumInputValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends MinimumOutputValueT = MinimumOutputValueT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: JobName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getJobNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getJobNames: () => JobName[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns the job names of all jobs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method register

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        register: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends MinimumArgumentValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends MinimumInputValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends MinimumOutputValueT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: JobName,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handler: JobHandler<A, I, O>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: RegisterJobOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ArgumentT extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        InputT extends string | number | boolean | JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OutputT extends string | number | boolean | JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handler: JobHandler<ArgumentT, InputT, OutputT>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: RegisterJobOptions & { name: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register a job handler. The name must be unique.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The function that will be called for the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An optional list of options to override the handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Register a job handler. The name must be unique.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The function that will be called for the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An optional list of options to override the handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SimpleScheduler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SimpleScheduler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinimumArgumentT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinimumInputT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinimumOutputT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > implements Scheduler<MinimumArgumentT, MinimumInputT, MinimumOutputT> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Simple scheduler. Should be the base of all registries and schedulers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _schemaRegistry?: schema.SchemaRegistry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDescription: (name: JobName) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Get a job description for a named job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A description, or null if the job is not registered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          has: (name: JobName) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns true if the job name has been registered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            True if the job exists, false otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method pause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pause: () => () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be used to resume execution. If multiple pause() were called, all their resume functions must be called before the Scheduler actually starts new jobs. Additional calls to the same resume function will have no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Jobs already running are NOT paused. This is pausing the scheduler only.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method schedule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          schedule: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A extends MinimumArgumentT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          I extends MinimumInputT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          O extends MinimumOutputT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: JobName,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          argument: A,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: ScheduleJobOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Job<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Schedule a job to be run, using its name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of job to be run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The argument to send to the job when starting it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Scheduling options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The Job being run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Job

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Job<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ArgumentT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          InputT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          OutputT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A Job instance, returned from scheduling a job. A Job instance is _not_ serializable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly argument: ArgumentT;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Argument sent when scheduling the job. This is a copy of the argument.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly description: Observable<JobDescription>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Description of the job. Resolving the job's description can be done asynchronously, so this is an observable that will resolve when it's ready.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inboundBus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly inboundBus: Observer<JobInboundMessage<InputT>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The JobInboundMessage messages TO the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly input: Observer<InputT>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The input to the job. This goes through the input channel as messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property outboundBus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly outboundBus: Observable<JobOutboundMessage<OutputT>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The JobOutboundMessage FROM the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly output: Observable<OutputT>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Outputs of this job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly state: JobState;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The current state of the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getChannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getChannel: <T extends string | number | boolean | JsonObject | JsonArray>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          schema?: schema.JsonSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Get a channel that validates against the schema. Messages will be filtered by the schema.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The name of the channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            A schema to use to validate messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ping: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Pings the job and wait for the resulting Pong before completing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stop: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Stops the job from running. This is different than unsubscribing from the output as in it sends the JobInboundMessageKind.Stop raw input to the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JobDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JobDescription extends JsonObject {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Metadata associated with a job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly argument: DeepReadonly<schema.JsonSchema>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly input: DeepReadonly<schema.JsonSchema>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly name: JobName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly output: DeepReadonly<schema.JsonSchema>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobDispatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobDispatcher<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  A extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  I extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  O extends JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > extends JobHandler<A, I, O> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A JobDispatcher can be used to dispatch between multiple jobs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addConditionalJob

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addConditionalJob: (predicate: (args: A) => boolean, name: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Add a conditional job that will be selected if the input fits a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter predicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setDefaultJob

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setDefaultJob: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: JobName | null | JobHandler<JsonValue, JsonValue, JsonValue>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Set the default job if all conditionals failed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The default name if all conditions are false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobHandler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ArgT extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  InputT extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OutputT extends JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  > {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The job handler function, which is a method that's executed for the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property jobDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  jobDescription: Partial<JobDescription>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (argument: ArgT, context: JobHandlerContext<ArgT, InputT, OutputT>): Observable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    JobOutboundMessage<OutputT>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface JobHandlerContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface JobHandlerContext<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumArgumentValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumInputValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumOutputValueT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The context in which the job is run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property dependencies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly dependencies: Job<JsonValue, JsonValue, JsonValue>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly description: JobDescription;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inboundBus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly inboundBus: Observable<JobInboundMessage<MinimumInputValueT>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scheduler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly scheduler: Scheduler<JsonValue, JsonValue, JsonValue>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JobInboundMessageBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JobInboundMessageBase extends JsonObject {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Base interface for the all job inbound messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly kind: JobInboundMessageKind;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The kind of message this is.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JobInboundMessageInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JobInboundMessageInput<InputT extends JsonValue>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extends JobInboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • A Job wants to send a message to a channel. This can be marshaled, and the Job object has helpers to transform this into an observable. The context also can create RxJS subjects that marshall messages through a channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly kind: JobInboundMessageKind.Input;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly value: InputT;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The input being sent to the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JobInboundMessagePing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JobInboundMessagePing extends JobInboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A ping to the job. The job should reply with a pong as soon as possible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly id: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • An ID that should be returned in the corresponding Pong.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly kind: JobInboundMessageKind.Ping;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobInboundMessageStop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobInboundMessageStop extends JobInboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Stop the job. This is handled by the job itself and jobs might not handle it. It will also unsubscribe from the Observable<>. This is equivalent to SIGTERM.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly kind: JobInboundMessageKind.Stop;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Base interface for the all job messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly description: JobDescription;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The job description.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind: JobOutboundMessageKind;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The kind of message this is.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageChannelBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageChannelBase extends JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Base interface for all job message related to channels.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The name of the channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageChannelComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageChannelComplete extends JobOutboundMessageChannelBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A job wants to close the channel, as completed. This is done automatically when the job ends, or can be done from the job to close it. A closed channel might be reopened, but the user need to recall getChannel().

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind: JobOutboundMessageKind.ChannelComplete;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface JobOutboundMessageChannelCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface JobOutboundMessageChannelCreate extends JobOutboundMessageChannelBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A job wants to create a new channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly kind: JobOutboundMessageKind.ChannelCreate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JobOutboundMessageChannelError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JobOutboundMessageChannelError extends JobOutboundMessageChannelBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A job wants to send an error to one of its channel. This is the equivalent of throwing through an Observable. The side channel will not receive any more messages after this, and will not complete.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly error: JsonValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The error message being sent to the channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly kind: JobOutboundMessageKind.ChannelError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JobOutboundMessageChannelMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JobOutboundMessageChannelMessage extends JobOutboundMessageChannelBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A job wants to send a message to a channel. This can be marshaled, and the Job object has helpers to transform this into an observable. The context also can create RxJS subjects that marshall messages through a channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly kind: JobOutboundMessageKind.ChannelMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly message: JsonValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The message being sent to the channel.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JobOutboundMessageEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JobOutboundMessageEnd extends JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • OnEnd of the job run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly kind: JobOutboundMessageKind.End;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JobOutboundMessageOnReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JobOutboundMessageOnReady extends JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The job has been created and will validate its input.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly kind: JobOutboundMessageKind.OnReady;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JobOutboundMessageOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JobOutboundMessageOutput<OutputT extends JsonValue>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • An output value is available.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly kind: JobOutboundMessageKind.Output;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly value: OutputT;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The message being outputted from the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobOutboundMessagePong

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JobOutboundMessagePong extends JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A pong response from a ping input. The id is the same as the one passed in.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly id: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The ID that was passed in the Ping messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly kind: JobOutboundMessageKind.Pong;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JobOutboundMessageStart extends JobOutboundMessageBase {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The job started. This is done by the job itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind: JobOutboundMessageKind.Start;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RegisterJobOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RegisterJobOptions extends Partial<JobDescription> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • SimpleJobRegistry job registration options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Registry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Registry<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumArgumentValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumInputValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MinimumOutputValueT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        get: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends MinimumArgumentValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends MinimumInputValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends MinimumOutputValueT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: JobName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get a job handler.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the job to get a handler from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScheduleJobOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScheduleJobOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Options for scheduling jobs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dependencies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dependencies?: Job | Job[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Jobs that need to finish before scheduling this job. These dependencies will be passed to the job itself in its context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Scheduler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Scheduler<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinimumArgumentValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinimumInputValueT extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MinimumOutputValueT extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • An interface that can schedule jobs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDescription: (name: JobName) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get a job description for a named job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A description, or null if no description is available for this job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        has: (name: JobName) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Returns true if the job name has been registered.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of the job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          True if the job exists, false otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pause: () => () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be used to resume execution. If multiple pause() were called, all their resume functions must be called before the Scheduler actually starts new jobs. Additional calls to the same resume function will have no effect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Jobs already running are NOT paused. This is pausing the scheduler only.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          A function that can be run to resume the scheduler. If multiple pause() calls were made, all their return function must be called (in any order) before the scheduler can resume.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method schedule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        schedule: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends MinimumArgumentValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends MinimumInputValueT,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends MinimumOutputValueT
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: JobName,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        argument: A,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: ScheduleJobOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Job<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Schedule a job to be run, using its name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The name of job to be run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter argument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The argument to send to the job when starting it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Scheduling options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The job being run.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SimpleJobHandlerContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SimpleJobHandlerContext<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > extends JobHandlerContext<A, I, O> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Interface for the JobHandler context that is used when using createJobHandler(). It extends the basic JobHandlerContext with additional functionality.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property createChannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createChannel: (name: string) => Observer<JsonValue>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          input: Observable<I>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum JobInboundMessageKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum JobInboundMessageKind {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ping = 'ip',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Stop = 'is',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Input = 'in',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Messages that can be sent TO a job. The job needs to listen to those.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Input = 'in'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Ping

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Ping = 'ip'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Stop = 'is'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum JobOutboundMessageKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enum JobOutboundMessageKind {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OnReady = 'c',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Start = 's',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  End = 'e',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pong = 'p',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Output = 'o',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChannelCreate = 'cn',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChannelMessage = 'cm',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChannelError = 'ce',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChannelComplete = 'cc',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Kind of messages that can be outputted from a job.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member ChannelComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChannelComplete = 'cc'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member ChannelCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ChannelCreate = 'cn'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member ChannelError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ChannelError = 'ce'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member ChannelMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ChannelMessage = 'cm'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member End

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          End = 'e'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member OnReady

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            OnReady = 'c'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Output = 'o'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Pong

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Pong = 'p'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Start = 's'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum JobState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum JobState {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Queued = 'queued',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ready = 'ready',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Started = 'started',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ended = 'ended',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Errored = 'errored',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The state of a job. These are changed as the job reports a new state through its messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Ended

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ended = 'ended'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The job has ended and is done running.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Errored

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Errored = 'errored'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • An error occured and the job stopped because of internal state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Queued

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Queued = 'queued'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The job was queued and is waiting to start.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Ready

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Ready = 'ready'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The job description was found, its dependencies (see "Synchronizing and Dependencies") are done running, and the job's argument is validated and the job's code will be executed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Started

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Started = 'started'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The job has been started. The job implementation is expected to send this as soon as its work is starting.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type JobInboundMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type JobInboundMessage<InputT extends JsonValue> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | JobInboundMessagePing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | JobInboundMessageStop
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | JobInboundMessageInput<InputT>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type JobName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type JobName = string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A job name is just a string (needs to be serializable).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type JobOutboundMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type JobOutboundMessage<OutputT extends JsonValue> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageOnReady
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageStart
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageOutput<OutputT>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageChannelCreate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageChannelMessage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageChannelError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageChannelComplete
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessageEnd
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | JobOutboundMessagePong;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generic message type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SimpleJobHandlerFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SimpleJobHandlerFn<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      A extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      I extends JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      O extends JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      input: A,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      context: SimpleJobHandlerContext<A, I, O>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => O | Promise<O> | Observable<O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • A simple version of the JobHandler. This simplifies a lot of the interaction with the job scheduler and registry. For example, instead of returning a JobOutboundMessage observable, you can directly return an output.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace experimental.jobs.strategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace experimental.jobs.strategy {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function memoize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        memoize: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replayMessages?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => JobStrategy<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creates a JobStrategy that will reuse a running job if the argument matches.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter replayMessages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Replay ALL messages if a job is reused, otherwise just hook up where it is.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function reuse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reuse: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replayMessages?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => JobStrategy<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creates a JobStrategy that will always reuse a running job, and restart it if the job ended.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter replayMessages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Replay ALL messages if a job is reused, otherwise just hook up where it is.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serialize: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends string | number | boolean | JsonObject | JsonArray =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >() => JobStrategy<A, I, O>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Creates a JobStrategy that serializes every call. This strategy can be mixed between jobs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type JobStrategy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type JobStrategy<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        A extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        I extends JsonValue = JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        O extends JsonValue = JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        handler: JobHandler<A, I, O>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?: Partial<Readonly<JobDescription>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => JobHandler<A, I, O>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace json

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'src/json/index.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isJsonArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isJsonArray: (value: JsonValue) => value is JsonArray;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isJsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isJsonObject: (value: JsonValue) => value is JsonObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function parseJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseJson: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              input: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode?: JsonParseMode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: ParseJsonOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => JsonValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Parse a JSON string into its value. This discards the AST and only returns the value itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If a path option is pass, it also absorbs JSON parsing errors and return a new error with the path in it. Useful for showing errors when parsing from a file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to parse.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The mode to parse the input with. .

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Additional optinos for parsing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {JsonValue} The value represented by the JSON string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function parseJsonAst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseJsonAst: (input: string, mode?: JsonParseMode) => JsonAstNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Parse the JSON string and return its AST. The AST may be losing data (end comments are discarded for example, and space characters are not represented in the AST), but all values will have a single node in the AST (a 1-to-1 mapping).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The mode to parse the input with. .

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {JsonAstNode} The root node of the value of the AST.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class InvalidJsonCharacterException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class InvalidJsonCharacterException extends JsonException {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • A character was invalid in this context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(context: JsonParserContext);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property character

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                character: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property invalidChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  invalidChar: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    line: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class JsonException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class JsonException extends BaseException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PathSpecificJsonException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PathSpecificJsonException extends JsonException {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • An error happened within a file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(path: string, exception: JsonException);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property exception

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            exception: JsonException;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UnexpectedEndOfInputException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class UnexpectedEndOfInputException extends JsonException {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • More input was expected, but we reached the end of the stream.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(_context: JsonParserContext);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonArray extends Array<JsonValue> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JsonAstArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JsonAstArray extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly elements: JsonAstNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly kind: 'array';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly value: JsonArray;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JsonAstComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface JsonAstComment extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly content: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly kind: 'comment';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonAstConstantFalse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonAstConstantFalse extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind: 'false';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly value: false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonAstConstantNull

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonAstConstantNull extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly kind: 'null';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly value: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JsonAstConstantTrue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface JsonAstConstantTrue extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly kind: 'true';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly value: true;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JsonAstIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JsonAstIdentifier extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly kind: 'identifier';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JsonAstKeyValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JsonAstKeyValue extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly key: JsonAstString | JsonAstIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly kind: 'keyvalue';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly value: JsonAstNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonAstMultilineComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonAstMultilineComment extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly content: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly kind: 'multicomment';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonAstNodeBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property comments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly comments?: (JsonAstComment | JsonAstMultilineComment)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly end: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly start: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonAstNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface JsonAstNumber extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind: 'number';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonAstObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonAstObject extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly kind: 'object';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly properties: JsonAstKeyValue[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly value: JsonObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JsonAstString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface JsonAstString extends JsonAstNodeBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly kind: 'string';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface JsonObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface JsonObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [prop: string]: JsonValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JsonParserContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface JsonParserContext {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Context passed around the parser with information about where we currently are in the parse.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly mode: JsonParseMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              position: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property previous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                previous: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ParseJsonOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ParseJsonOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Options for the parseJson() function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If omitted, will only emit errors related to the content of the JSON. If specified, any JSON errors will also include the path of the file that caused the error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Position {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property character

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly character: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly line: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum JsonParseMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum JsonParseMode {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Strict = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CommentsAllowed = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SingleQuotesAllowed = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IdentifierKeyNamesAllowed = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TrailingCommasAllowed = 8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HexadecimalNumberAllowed = 16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MultiLineStringAllowed = 32,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LaxNumberParsingAllowed = 64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NumberConstantsAllowed = 128,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Default = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Loose = 255,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Json = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Json5 = 255,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The Parse mode used for parsing the JSON string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member CommentsAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CommentsAllowed = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Default

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Default = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member HexadecimalNumberAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            HexadecimalNumberAllowed = 16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member IdentifierKeyNamesAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IdentifierKeyNamesAllowed = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Json

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Json = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Json5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Json5 = 255

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member LaxNumberParsingAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    LaxNumberParsingAllowed = 64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Loose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Loose = 255

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member MultiLineStringAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MultiLineStringAllowed = 32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member NumberConstantsAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NumberConstantsAllowed = 128

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member SingleQuotesAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SingleQuotesAllowed = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Strict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Strict = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member TrailingCommasAllowed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TrailingCommasAllowed = 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type JsonAstNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type JsonAstNode =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstNumber
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstString
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstIdentifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstConstantFalse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstConstantNull
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JsonAstConstantTrue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type JsonValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type JsonValue = JsonAstNode['value'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'src/json/schema/index.d.ts' {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Copyright Google LLC All Rights Reserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function buildJsonPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buildJsonPointer: (fragments: string[]) => JsonPointer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function getTypesOfSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getTypesOfSchema: (schema: JsonSchema) => Set<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isJsonSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isJsonSchema: (value: unknown) => value is JsonSchema;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function joinJsonPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            joinJsonPointer: (root: JsonPointer, ...others: string[]) => JsonPointer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function mergeSchemas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mergeSchemas: (...schemas: (JsonSchema | undefined)[]) => JsonSchema;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Return a schema that is the merge of all subschemas, ie. it should validate all the schemas that were passed in. It is possible to make an invalid schema this way, e.g. by using mergeSchemas({ type: 'number' }, { type: 'string' }), which will never validate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter schemas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                All schemas to be merged.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function parseJsonPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseJsonPointer: (pointer: JsonPointer) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function visitJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                visitJson: <ContextT>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                json: JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                visitor: JsonVisitor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schema?