@angular-devkit/core

  • Version 18.0.1
  • Published
  • 261 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

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 deepCopy

        deepCopy: <T>(value: T) => T;
        • 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 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 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 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 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 InvalidPathException

                                  class InvalidPathException 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 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 UnknownException

                                                                                      class UnknownException extends BaseException {}

                                                                                        constructor

                                                                                        constructor(message: string);

                                                                                          Interfaces

                                                                                          interface JsonArray

                                                                                          interface JsonArray extends Array<JsonValue> {}
                                                                                          • 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

                                                                                          interface JsonObject

                                                                                          interface JsonObject {}

                                                                                            index signature

                                                                                            [prop: string]: JsonValue;

                                                                                              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;

                                                                                                                                        Type Aliases

                                                                                                                                        type JsonValue

                                                                                                                                        type JsonValue = boolean | string | number | JsonArray | JsonObject | null;

                                                                                                                                          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 TemplateAstNode

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

                                                                                                                                              type WindowsPath

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

                                                                                                                                                Namespaces

                                                                                                                                                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;

                                                                                                                                                    interface JsonArray

                                                                                                                                                    interface JsonArray extends Array<JsonValue> {}
                                                                                                                                                    • 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

                                                                                                                                                    interface JsonObject

                                                                                                                                                    interface JsonObject {}

                                                                                                                                                      index signature

                                                                                                                                                      [prop: string]: JsonValue;

                                                                                                                                                        type JsonValue

                                                                                                                                                        type JsonValue = boolean | string | number | JsonArray | JsonObject | null;

                                                                                                                                                          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?: JsonSchema,
                                                                                                                                                                    refResolver?: ReferenceResolver<ContextT>,
                                                                                                                                                                    context?: ContextT
                                                                                                                                                                    ) => Observable<JsonValue>;
                                                                                                                                                                    • Visit all the properties in a JSON object, allowing to transform them. It supports calling properties synchronously or asynchronously (through Observables). The original object can be mutated or replaced entirely. In case where it's replaced, the new value is returned. When it's mutated though the original object will be changed.

                                                                                                                                                                      Please note it is possible to have an infinite loop here (which will result in a stack overflow) if you return 2 objects that references each others (or the same object all the time).

                                                                                                                                                                      Parameter json

                                                                                                                                                                      The Json value to visit.

                                                                                                                                                                      Parameter visitor

                                                                                                                                                                      A function that will be called on every items.

                                                                                                                                                                      Parameter schema

                                                                                                                                                                      A JSON schema to pass through to the visitor (where possible).

                                                                                                                                                                      Parameter refResolver

                                                                                                                                                                      a function to resolve references in the schema.

                                                                                                                                                                      Returns

                                                                                                                                                                      {Observable< | undefined>} The observable of the new root, if the root changed.

                                                                                                                                                                    function visitJsonSchema

                                                                                                                                                                    visitJsonSchema: (schema: JsonSchema, visitor: JsonSchemaVisitor) => void;

                                                                                                                                                                      class CoreSchemaRegistry

                                                                                                                                                                      class CoreSchemaRegistry implements SchemaRegistry {}

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(formats?: SchemaFormat[]);

                                                                                                                                                                          method addFormat

                                                                                                                                                                          addFormat: (format: SchemaFormat) => void;

                                                                                                                                                                            method addPostTransform

                                                                                                                                                                            addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                            • Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.

                                                                                                                                                                              Parameter visitor

                                                                                                                                                                              The visitor to transform every value.

                                                                                                                                                                              Parameter deps

                                                                                                                                                                              A list of other visitors to run before.

                                                                                                                                                                            method addPreTransform

                                                                                                                                                                            addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                            • Add a transformation step before the validation of any Json.

                                                                                                                                                                              Parameter visitor

                                                                                                                                                                              The visitor to transform every value.

                                                                                                                                                                              Parameter deps

                                                                                                                                                                              A list of other visitors to run before.

                                                                                                                                                                            method addSmartDefaultProvider

                                                                                                                                                                            addSmartDefaultProvider: <T>(
                                                                                                                                                                            source: string,
                                                                                                                                                                            provider: SmartDefaultProvider<T>
                                                                                                                                                                            ) => void;

                                                                                                                                                                              method compile

                                                                                                                                                                              compile: (schema: JsonSchema) => Promise<SchemaValidator>;
                                                                                                                                                                              • Compile and return a validation function for the Schema.

                                                                                                                                                                                Parameter schema

                                                                                                                                                                                The schema to validate. If a string, will fetch the schema before compiling it (using schema as a URI).

                                                                                                                                                                              method ɵflatten

                                                                                                                                                                              ɵflatten: (schema: JsonObject) => Promise<JsonObject>;
                                                                                                                                                                              • Flatten the Schema, resolving and replacing all the refs. Makes it into a synchronous schema that is also easier to traverse. Does not cache the result.

                                                                                                                                                                                Producing a flatten schema document does not in all cases produce a schema with identical behavior to the original. See: https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.appendix.B.2

                                                                                                                                                                                Parameter schema

                                                                                                                                                                                The schema or URI to flatten.

                                                                                                                                                                                Returns

                                                                                                                                                                                An Observable of the flattened schema object. since 11.2 without replacement.

                                                                                                                                                                              method registerUriHandler

                                                                                                                                                                              registerUriHandler: (handler: UriHandler) => void;

                                                                                                                                                                                method usePromptProvider

                                                                                                                                                                                usePromptProvider: (provider: PromptProvider) => void;

                                                                                                                                                                                  method useXDeprecatedProvider

                                                                                                                                                                                  useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

                                                                                                                                                                                    class SchemaValidationException

                                                                                                                                                                                    class SchemaValidationException extends BaseException {}

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(errors?: ErrorObject[], baseMessage?: string);

                                                                                                                                                                                        property errors

                                                                                                                                                                                        readonly errors: ErrorObject[];

                                                                                                                                                                                          method createMessages

                                                                                                                                                                                          static createMessages: (errors?: SchemaValidatorError[]) => string[];

                                                                                                                                                                                            interface JsonSchemaVisitor

                                                                                                                                                                                            interface JsonSchemaVisitor {}

                                                                                                                                                                                              call signature

                                                                                                                                                                                              (
                                                                                                                                                                                              current: JsonObject | JsonArray,
                                                                                                                                                                                              pointer: JsonPointer,
                                                                                                                                                                                              parentSchema?: JsonObject | JsonArray,
                                                                                                                                                                                              index?: string
                                                                                                                                                                                              ): void;

                                                                                                                                                                                                interface JsonVisitor

                                                                                                                                                                                                interface JsonVisitor {}

                                                                                                                                                                                                  call signature

                                                                                                                                                                                                  (
                                                                                                                                                                                                  value: JsonValue,
                                                                                                                                                                                                  pointer: JsonPointer,
                                                                                                                                                                                                  schema?: JsonObject,
                                                                                                                                                                                                  root?: JsonObject | JsonArray
                                                                                                                                                                                                  ): Observable<JsonValue> | JsonValue;

                                                                                                                                                                                                    interface PromptDefinition

                                                                                                                                                                                                    interface PromptDefinition {}

                                                                                                                                                                                                      property default

                                                                                                                                                                                                      default?: string | string[] | number | boolean | null;

                                                                                                                                                                                                        property id

                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                          property items

                                                                                                                                                                                                          items?: Array<
                                                                                                                                                                                                          | string
                                                                                                                                                                                                          | {
                                                                                                                                                                                                          value: JsonValue;
                                                                                                                                                                                                          label: string;
                                                                                                                                                                                                          }
                                                                                                                                                                                                          >;

                                                                                                                                                                                                            property message

                                                                                                                                                                                                            message: string;

                                                                                                                                                                                                              property multiselect

                                                                                                                                                                                                              multiselect?: boolean;

                                                                                                                                                                                                                property propertyTypes

                                                                                                                                                                                                                propertyTypes: Set<string>;

                                                                                                                                                                                                                  property raw

                                                                                                                                                                                                                  raw?: string | JsonObject;

                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                      property validator

                                                                                                                                                                                                                      validator?: (value: JsonValue) => boolean | string | Promise<boolean | string>;

                                                                                                                                                                                                                        interface ReferenceResolver

                                                                                                                                                                                                                        interface ReferenceResolver<ContextT> {}

                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                          (ref: string, context?: ContextT): {
                                                                                                                                                                                                                          context?: ContextT;
                                                                                                                                                                                                                          schema?: JsonObject;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            interface SchemaFormat

                                                                                                                                                                                                                            interface SchemaFormat {}

                                                                                                                                                                                                                              property formatter

                                                                                                                                                                                                                              formatter: SchemaFormatter;

                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                  interface SchemaKeywordValidator

                                                                                                                                                                                                                                  interface SchemaKeywordValidator {}

                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                    data: JsonValue,
                                                                                                                                                                                                                                    schema: JsonValue,
                                                                                                                                                                                                                                    parent: JsonObject | JsonArray | undefined,
                                                                                                                                                                                                                                    parentProperty: string | number | undefined,
                                                                                                                                                                                                                                    pointer: JsonPointer,
                                                                                                                                                                                                                                    rootData: JsonValue
                                                                                                                                                                                                                                    ): boolean | Observable<boolean>;

                                                                                                                                                                                                                                      interface SchemaRegistry

                                                                                                                                                                                                                                      interface SchemaRegistry {}

                                                                                                                                                                                                                                        method addFormat

                                                                                                                                                                                                                                        addFormat: (format: SchemaFormat) => void;

                                                                                                                                                                                                                                          method addPostTransform

                                                                                                                                                                                                                                          addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                                                                                          • Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.

                                                                                                                                                                                                                                            Parameter visitor

                                                                                                                                                                                                                                            The visitor to transform every value.

                                                                                                                                                                                                                                            Parameter deps

                                                                                                                                                                                                                                            A list of other visitors to run before.

                                                                                                                                                                                                                                          method addPreTransform

                                                                                                                                                                                                                                          addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                                                                                          • Add a transformation step before the validation of any Json.

                                                                                                                                                                                                                                            Parameter visitor

                                                                                                                                                                                                                                            The visitor to transform every value.

                                                                                                                                                                                                                                            Parameter deps

                                                                                                                                                                                                                                            A list of other visitors to run before.

                                                                                                                                                                                                                                          method addSmartDefaultProvider

                                                                                                                                                                                                                                          addSmartDefaultProvider: <T>(
                                                                                                                                                                                                                                          source: string,
                                                                                                                                                                                                                                          provider: SmartDefaultProvider<T>
                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                            method compile

                                                                                                                                                                                                                                            compile: (schema: Object) => Promise<SchemaValidator>;

                                                                                                                                                                                                                                              method ɵflatten

                                                                                                                                                                                                                                              ɵflatten: (schema: JsonObject | string) => Promise<JsonObject>;

                                                                                                                                                                                                                                              method usePromptProvider

                                                                                                                                                                                                                                              usePromptProvider: (provider: PromptProvider) => void;

                                                                                                                                                                                                                                                method useXDeprecatedProvider

                                                                                                                                                                                                                                                useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

                                                                                                                                                                                                                                                  interface SchemaValidator

                                                                                                                                                                                                                                                  interface SchemaValidator {}

                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                    data: JsonValue,
                                                                                                                                                                                                                                                    options?: SchemaValidatorOptions
                                                                                                                                                                                                                                                    ): Promise<SchemaValidatorResult>;

                                                                                                                                                                                                                                                      interface SchemaValidatorOptions

                                                                                                                                                                                                                                                      interface SchemaValidatorOptions {}

                                                                                                                                                                                                                                                        property applyPostTransforms

                                                                                                                                                                                                                                                        applyPostTransforms?: boolean;

                                                                                                                                                                                                                                                          property applyPreTransforms

                                                                                                                                                                                                                                                          applyPreTransforms?: boolean;

                                                                                                                                                                                                                                                            property withPrompts

                                                                                                                                                                                                                                                            withPrompts?: boolean;

                                                                                                                                                                                                                                                              interface SchemaValidatorResult

                                                                                                                                                                                                                                                              interface SchemaValidatorResult {}

                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                data: JsonValue;

                                                                                                                                                                                                                                                                  property errors

                                                                                                                                                                                                                                                                  errors?: SchemaValidatorError[];

                                                                                                                                                                                                                                                                    property success

                                                                                                                                                                                                                                                                    success: boolean;

                                                                                                                                                                                                                                                                      interface SmartDefaultProvider

                                                                                                                                                                                                                                                                      interface SmartDefaultProvider<T> {}

                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                        (schema: JsonObject): T | Observable<T>;

                                                                                                                                                                                                                                                                          type JsonPointer

                                                                                                                                                                                                                                                                          type JsonPointer = string & {
                                                                                                                                                                                                                                                                          __PRIVATE_DEVKIT_JSON_POINTER: void;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            type JsonSchema

                                                                                                                                                                                                                                                                            type JsonSchema = JsonObject | boolean;
                                                                                                                                                                                                                                                                            • A specialized interface for JsonSchema (to come). JsonSchemas are also JsonObject.

                                                                                                                                                                                                                                                                              Modifiers

                                                                                                                                                                                                                                                                              • @public

                                                                                                                                                                                                                                                                            type PromptProvider

                                                                                                                                                                                                                                                                            type PromptProvider = (definitions: Array<PromptDefinition>) => ObservableInput<{
                                                                                                                                                                                                                                                                            [id: string]: JsonValue;
                                                                                                                                                                                                                                                                            }>;

                                                                                                                                                                                                                                                                              type SchemaFormatter

                                                                                                                                                                                                                                                                              type SchemaFormatter = Format;

                                                                                                                                                                                                                                                                                type SchemaValidatorError

                                                                                                                                                                                                                                                                                type SchemaValidatorError = Partial<ErrorObject>;

                                                                                                                                                                                                                                                                                  type UriHandler

                                                                                                                                                                                                                                                                                  type UriHandler = (
                                                                                                                                                                                                                                                                                  uri: string
                                                                                                                                                                                                                                                                                  ) => Observable<JsonObject> | Promise<JsonObject> | null | undefined;

                                                                                                                                                                                                                                                                                    namespace transforms

                                                                                                                                                                                                                                                                                    module 'src/json/schema/transforms.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 addUndefinedDefaults

                                                                                                                                                                                                                                                                                    addUndefinedDefaults: (
                                                                                                                                                                                                                                                                                    value: JsonValue,
                                                                                                                                                                                                                                                                                    _pointer: JsonPointer,
                                                                                                                                                                                                                                                                                    schema?: JsonSchema
                                                                                                                                                                                                                                                                                    ) => JsonValue;

                                                                                                                                                                                                                                                                                      namespace logging

                                                                                                                                                                                                                                                                                      module 'src/logger/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

                                                                                                                                                                                                                                                                                      class IndentLogger

                                                                                                                                                                                                                                                                                      class IndentLogger extends Logger {}

                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                        constructor(name: string, parent?: Logger, indentation?: string);

                                                                                                                                                                                                                                                                                          class LevelCapLogger

                                                                                                                                                                                                                                                                                          class LevelCapLogger extends LevelTransformLogger {}

                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                            constructor(name: string, parent: Logger, levelCap: LogLevel);

                                                                                                                                                                                                                                                                                              property levelCap

                                                                                                                                                                                                                                                                                              readonly levelCap: LogLevel;

                                                                                                                                                                                                                                                                                                property levelMap

                                                                                                                                                                                                                                                                                                static levelMap: { [cap: string]: { [level: string]: string } };

                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                  readonly name: string;

                                                                                                                                                                                                                                                                                                    property parent

                                                                                                                                                                                                                                                                                                    readonly parent: Logger;

                                                                                                                                                                                                                                                                                                      class LevelTransformLogger

                                                                                                                                                                                                                                                                                                      class LevelTransformLogger extends Logger {}

                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                        parent: Logger,
                                                                                                                                                                                                                                                                                                        levelTransform: (level: LogLevel) => LogLevel
                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                          property levelTransform

                                                                                                                                                                                                                                                                                                          readonly levelTransform: (level: LogLevel) => LogLevel;

                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                            readonly name: string;

                                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                                              readonly parent: Logger;

                                                                                                                                                                                                                                                                                                                method createChild

                                                                                                                                                                                                                                                                                                                createChild: (name: string) => Logger;

                                                                                                                                                                                                                                                                                                                  method log

                                                                                                                                                                                                                                                                                                                  log: (level: LogLevel, message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                    class Logger

                                                                                                                                                                                                                                                                                                                    class Logger extends Observable<LogEntry> implements LoggerApi {}

                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                      constructor(name: string, parent?: Logger);

                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                        readonly name: string;

                                                                                                                                                                                                                                                                                                                          property parent

                                                                                                                                                                                                                                                                                                                          readonly parent: Logger;

                                                                                                                                                                                                                                                                                                                            method asApi

                                                                                                                                                                                                                                                                                                                            asApi: () => LoggerApi;

                                                                                                                                                                                                                                                                                                                              method complete

                                                                                                                                                                                                                                                                                                                              complete: () => void;

                                                                                                                                                                                                                                                                                                                                method createChild

                                                                                                                                                                                                                                                                                                                                createChild: (name: string) => Logger;

                                                                                                                                                                                                                                                                                                                                  method debug

                                                                                                                                                                                                                                                                                                                                  debug: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                    method error

                                                                                                                                                                                                                                                                                                                                    error: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                      method fatal

                                                                                                                                                                                                                                                                                                                                      fatal: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                        method forEach

                                                                                                                                                                                                                                                                                                                                        forEach: (
                                                                                                                                                                                                                                                                                                                                        next: (value: LogEntry) => void,
                                                                                                                                                                                                                                                                                                                                        promiseCtor?: PromiseConstructorLike
                                                                                                                                                                                                                                                                                                                                        ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                          method info

                                                                                                                                                                                                                                                                                                                                          info: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                            method lift

                                                                                                                                                                                                                                                                                                                                            lift: <R>(operator: Operator<LogEntry, R>) => Observable<R>;

                                                                                                                                                                                                                                                                                                                                              method log

                                                                                                                                                                                                                                                                                                                                              log: (level: LogLevel, message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                method next

                                                                                                                                                                                                                                                                                                                                                next: (entry: LogEntry) => void;

                                                                                                                                                                                                                                                                                                                                                  method subscribe

                                                                                                                                                                                                                                                                                                                                                  subscribe: {
                                                                                                                                                                                                                                                                                                                                                  (): Subscription;
                                                                                                                                                                                                                                                                                                                                                  (observer: PartialObserver<LogEntry>): Subscription;
                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                  next?: (value: LogEntry) => void,
                                                                                                                                                                                                                                                                                                                                                  error?: (error: Error) => void,
                                                                                                                                                                                                                                                                                                                                                  complete?: () => void
                                                                                                                                                                                                                                                                                                                                                  ): Subscription;
                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                                                                                                                                    toString: () => string;

                                                                                                                                                                                                                                                                                                                                                      method warn

                                                                                                                                                                                                                                                                                                                                                      warn: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                        class NullLogger

                                                                                                                                                                                                                                                                                                                                                        class NullLogger extends Logger {}

                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                          constructor(parent?: Logger);

                                                                                                                                                                                                                                                                                                                                                            method asApi

                                                                                                                                                                                                                                                                                                                                                            asApi: () => LoggerApi;

                                                                                                                                                                                                                                                                                                                                                              class TransformLogger

                                                                                                                                                                                                                                                                                                                                                              class TransformLogger extends Logger {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                transform: (stream: Observable<LogEntry>) => Observable<LogEntry>,
                                                                                                                                                                                                                                                                                                                                                                parent?: Logger
                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                  interface LogEntry

                                                                                                                                                                                                                                                                                                                                                                  interface LogEntry extends LoggerMetadata {}

                                                                                                                                                                                                                                                                                                                                                                    property level

                                                                                                                                                                                                                                                                                                                                                                    level: LogLevel;

                                                                                                                                                                                                                                                                                                                                                                      property message

                                                                                                                                                                                                                                                                                                                                                                      message: string;

                                                                                                                                                                                                                                                                                                                                                                        property timestamp

                                                                                                                                                                                                                                                                                                                                                                        timestamp: number;

                                                                                                                                                                                                                                                                                                                                                                          interface LoggerApi

                                                                                                                                                                                                                                                                                                                                                                          interface LoggerApi {}

                                                                                                                                                                                                                                                                                                                                                                            method createChild

                                                                                                                                                                                                                                                                                                                                                                            createChild: (name: string) => Logger;

                                                                                                                                                                                                                                                                                                                                                                              method debug

                                                                                                                                                                                                                                                                                                                                                                              debug: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                method error

                                                                                                                                                                                                                                                                                                                                                                                error: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                  method fatal

                                                                                                                                                                                                                                                                                                                                                                                  fatal: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                    method info

                                                                                                                                                                                                                                                                                                                                                                                    info: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                      method log

                                                                                                                                                                                                                                                                                                                                                                                      log: (level: LogLevel, message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method warn

                                                                                                                                                                                                                                                                                                                                                                                        warn: (message: string, metadata?: JsonObject) => void;

                                                                                                                                                                                                                                                                                                                                                                                          interface LoggerMetadata

                                                                                                                                                                                                                                                                                                                                                                                          interface LoggerMetadata extends JsonObject {}

                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                              path: string[];

                                                                                                                                                                                                                                                                                                                                                                                                type LogLevel

                                                                                                                                                                                                                                                                                                                                                                                                type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';

                                                                                                                                                                                                                                                                                                                                                                                                  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?: JsonSchema,
                                                                                                                                                                                                                                                                                                                                                                                                            refResolver?: ReferenceResolver<ContextT>,
                                                                                                                                                                                                                                                                                                                                                                                                            context?: ContextT
                                                                                                                                                                                                                                                                                                                                                                                                            ) => Observable<JsonValue>;
                                                                                                                                                                                                                                                                                                                                                                                                            • Visit all the properties in a JSON object, allowing to transform them. It supports calling properties synchronously or asynchronously (through Observables). The original object can be mutated or replaced entirely. In case where it's replaced, the new value is returned. When it's mutated though the original object will be changed.

                                                                                                                                                                                                                                                                                                                                                                                                              Please note it is possible to have an infinite loop here (which will result in a stack overflow) if you return 2 objects that references each others (or the same object all the time).

                                                                                                                                                                                                                                                                                                                                                                                                              Parameter json

                                                                                                                                                                                                                                                                                                                                                                                                              The Json value to visit.

                                                                                                                                                                                                                                                                                                                                                                                                              Parameter visitor

                                                                                                                                                                                                                                                                                                                                                                                                              A function that will be called on every items.

                                                                                                                                                                                                                                                                                                                                                                                                              Parameter schema

                                                                                                                                                                                                                                                                                                                                                                                                              A JSON schema to pass through to the visitor (where possible).

                                                                                                                                                                                                                                                                                                                                                                                                              Parameter refResolver

                                                                                                                                                                                                                                                                                                                                                                                                              a function to resolve references in the schema.

                                                                                                                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                                                                                                                              {Observable< | undefined>} The observable of the new root, if the root changed.

                                                                                                                                                                                                                                                                                                                                                                                                            function visitJsonSchema

                                                                                                                                                                                                                                                                                                                                                                                                            visitJsonSchema: (schema: JsonSchema, visitor: JsonSchemaVisitor) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              class CoreSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                              class CoreSchemaRegistry implements SchemaRegistry {}

                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                constructor(formats?: SchemaFormat[]);

                                                                                                                                                                                                                                                                                                                                                                                                                  method addFormat

                                                                                                                                                                                                                                                                                                                                                                                                                  addFormat: (format: SchemaFormat) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    method addPostTransform

                                                                                                                                                                                                                                                                                                                                                                                                                    addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter visitor

                                                                                                                                                                                                                                                                                                                                                                                                                      The visitor to transform every value.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter deps

                                                                                                                                                                                                                                                                                                                                                                                                                      A list of other visitors to run before.

                                                                                                                                                                                                                                                                                                                                                                                                                    method addPreTransform

                                                                                                                                                                                                                                                                                                                                                                                                                    addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Add a transformation step before the validation of any Json.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter visitor

                                                                                                                                                                                                                                                                                                                                                                                                                      The visitor to transform every value.

                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter deps

                                                                                                                                                                                                                                                                                                                                                                                                                      A list of other visitors to run before.

                                                                                                                                                                                                                                                                                                                                                                                                                    method addSmartDefaultProvider

                                                                                                                                                                                                                                                                                                                                                                                                                    addSmartDefaultProvider: <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                    source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                    provider: SmartDefaultProvider<T>
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      method compile

                                                                                                                                                                                                                                                                                                                                                                                                                      compile: (schema: JsonSchema) => Promise<SchemaValidator>;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Compile and return a validation function for the Schema.

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter schema

                                                                                                                                                                                                                                                                                                                                                                                                                        The schema to validate. If a string, will fetch the schema before compiling it (using schema as a URI).

                                                                                                                                                                                                                                                                                                                                                                                                                      method ɵflatten

                                                                                                                                                                                                                                                                                                                                                                                                                      ɵflatten: (schema: JsonObject) => Promise<JsonObject>;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Flatten the Schema, resolving and replacing all the refs. Makes it into a synchronous schema that is also easier to traverse. Does not cache the result.

                                                                                                                                                                                                                                                                                                                                                                                                                        Producing a flatten schema document does not in all cases produce a schema with identical behavior to the original. See: https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.appendix.B.2

                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter schema

                                                                                                                                                                                                                                                                                                                                                                                                                        The schema or URI to flatten.

                                                                                                                                                                                                                                                                                                                                                                                                                        Returns

                                                                                                                                                                                                                                                                                                                                                                                                                        An Observable of the flattened schema object. since 11.2 without replacement.

                                                                                                                                                                                                                                                                                                                                                                                                                      method registerUriHandler

                                                                                                                                                                                                                                                                                                                                                                                                                      registerUriHandler: (handler: UriHandler) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        method usePromptProvider

                                                                                                                                                                                                                                                                                                                                                                                                                        usePromptProvider: (provider: PromptProvider) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method useXDeprecatedProvider

                                                                                                                                                                                                                                                                                                                                                                                                                          useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            class SchemaValidationException

                                                                                                                                                                                                                                                                                                                                                                                                                            class SchemaValidationException extends BaseException {}

                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(errors?: ErrorObject[], baseMessage?: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                readonly errors: ErrorObject[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  method createMessages

                                                                                                                                                                                                                                                                                                                                                                                                                                  static createMessages: (errors?: SchemaValidatorError[]) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JsonSchemaVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface JsonSchemaVisitor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                      current: JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                      pointer: JsonPointer,
                                                                                                                                                                                                                                                                                                                                                                                                                                      parentSchema?: JsonObject | JsonArray,
                                                                                                                                                                                                                                                                                                                                                                                                                                      index?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface JsonVisitor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                          value: JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                          pointer: JsonPointer,
                                                                                                                                                                                                                                                                                                                                                                                                                                          schema?: JsonObject,
                                                                                                                                                                                                                                                                                                                                                                                                                                          root?: JsonObject | JsonArray
                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Observable<JsonValue> | JsonValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PromptDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PromptDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property default

                                                                                                                                                                                                                                                                                                                                                                                                                                              default?: string | string[] | number | boolean | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                  items?: Array<
                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: JsonValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  label: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property multiselect

                                                                                                                                                                                                                                                                                                                                                                                                                                                      multiselect?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property propertyTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                        propertyTypes: Set<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                                          raw?: string | JsonObject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property validator

                                                                                                                                                                                                                                                                                                                                                                                                                                                              validator?: (value: JsonValue) => boolean | string | Promise<boolean | string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReferenceResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReferenceResolver<ContextT> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (ref: string, context?: ContextT): {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  context?: ContextT;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  schema?: JsonObject;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SchemaFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SchemaFormat {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property formatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      formatter: SchemaFormatter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SchemaKeywordValidator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SchemaKeywordValidator {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            schema: JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parent: JsonObject | JsonArray | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentProperty: string | number | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pointer: JsonPointer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rootData: JsonValue
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): boolean | Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SchemaRegistry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addFormat: (format: SchemaFormat) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addPostTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter visitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The visitor to transform every value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter deps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A list of other visitors to run before.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addPreTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Add a transformation step before the validation of any Json.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter visitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The visitor to transform every value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter deps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A list of other visitors to run before.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addSmartDefaultProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addSmartDefaultProvider: <T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  provider: SmartDefaultProvider<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method compile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    compile: (schema: Object) => Promise<SchemaValidator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ɵflatten

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ɵflatten: (schema: JsonObject | string) => Promise<JsonObject>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method usePromptProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      usePromptProvider: (provider: PromptProvider) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method useXDeprecatedProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SchemaValidator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SchemaValidator {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: SchemaValidatorOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): Promise<SchemaValidatorResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SchemaValidatorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SchemaValidatorOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property applyPostTransforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                applyPostTransforms?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property applyPreTransforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  applyPreTransforms?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property withPrompts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    withPrompts?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SchemaValidatorResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SchemaValidatorResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: JsonValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          errors?: SchemaValidatorError[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property success

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            success: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SmartDefaultProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SmartDefaultProvider<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (schema: JsonObject): T | Observable<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type JsonPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type JsonPointer = string & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  __PRIVATE_DEVKIT_JSON_POINTER: void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type JsonSchema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type JsonSchema = JsonObject | boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A specialized interface for JsonSchema (to come). JsonSchemas are also JsonObject.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • @public

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PromptProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PromptProvider = (definitions: Array<PromptDefinition>) => ObservableInput<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [id: string]: JsonValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaFormatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SchemaFormatter = Format;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaValidatorError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SchemaValidatorError = Partial<ErrorObject>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UriHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UriHandler = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          uri: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Observable<JsonObject> | Promise<JsonObject> | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace transforms

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'src/json/schema/transforms.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 addUndefinedDefaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addUndefinedDefaults: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: JsonValue,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _pointer: JsonPointer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            schema?: JsonSchema
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => JsonValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'src/utils/strings.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 camelize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              camelize: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the lowerCamelCase form of a string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ```javascript camelize('innerHTML'); // 'innerHTML' camelize('action_name'); // 'actionName' camelize('css-class-name'); // 'cssClassName' camelize('my favorite items'); // 'myFavoriteItems' camelize('My Favorite Items'); // 'myFavoriteItems' ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                camelize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to camelize. {String} the camelized string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function capitalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              capitalize: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the Capitalized form of a string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ```javascript 'innerHTML'.capitalize() // 'InnerHTML' 'action_name'.capitalize() // 'Action_name' 'css-class-name'.capitalize() // 'Css-class-name' 'my favorite items'.capitalize() // 'My favorite items' ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                capitalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to capitalize. {String} The capitalized string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function classify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              classify: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns the UpperCamelCase form of a string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                the string to classify {String} the classified string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ```javascript 'innerHTML'.classify(); // 'InnerHTML' 'action_name'.classify(); // 'ActionName' 'css-class-name'.classify(); // 'CssClassName' 'my favorite items'.classify(); // 'MyFavoriteItems' 'app.component'.classify(); // 'AppComponent' ``` classify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function dasherize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dasherize: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Replaces underscores, spaces, or camelCase with dashes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ```javascript dasherize('innerHTML'); // 'inner-html' dasherize('action_name'); // 'action-name' dasherize('css-class-name'); // 'css-class-name' dasherize('my favorite items'); // 'my-favorite-items' ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dasherize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to dasherize. {String} the dasherized string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function decamelize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              decamelize: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Converts a camelized string into all lower case separated by underscores.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ```javascript decamelize('innerHTML'); // 'inner_html' decamelize('action_name'); // 'action_name' decamelize('css-class-name'); // 'css-class-name' decamelize('my favorite items'); // 'my favorite items' ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                decamelize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to decamelize. {String} the decamelized string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function levenshtein

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              levenshtein: (a: string, b: string) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Calculate the levenshtein distance of two strings. See https://en.wikipedia.org/wiki/Levenshtein_distance. Based off https://gist.github.com/andrei-m/982927 (for using the faster dynamic programming version).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                String a.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                String b.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                A number that represents the distance between the two strings. The greater the number the more distant the strings are from each others.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function underscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              underscore: (str: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • More general than decamelize. Returns the lower_case_and_underscored form of a string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ```javascript 'innerHTML'.underscore(); // 'inner_html' 'action_name'.underscore(); // 'action_name' 'css-class-name'.underscore(); // 'css_class_name' 'my favorite items'.underscore(); // 'my_favorite_items' ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                underscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter str

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The string to underscore. {String} the underscored string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace tags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'src/utils/literals.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 indentBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              indentBy: (indentations: number) => TemplateTag;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function oneLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                oneLine: (strings: TemplateStringsArray, ...values: any[]) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function stripIndent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stripIndent: (strings: TemplateStringsArray, ...values: any[]) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function stripIndents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stripIndents: (strings: TemplateStringsArray, ...values: any[]) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function trimNewlines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trimNewlines: (strings: TemplateStringsArray, ...values: any[]) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TemplateTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TemplateTag<R = string> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (template: TemplateStringsArray, ...substitutions: any[]): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace virtualFs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'src/virtual-fs/host/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 fileBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const fileBuffer: TemplateTag<ArrayBuffer>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            use stringToFileBuffer instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function createSyncHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createSyncHost: <StatsT extends object = {}>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          handler: SyncHostHandler<StatsT>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Host<StatsT>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function fileBufferToString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fileBufferToString: (fileBuffer: FileBuffer) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function stringToFileBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stringToFileBuffer: (str: string) => FileBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class AliasHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class AliasHost<StatsT extends object = {}> extends ResolverHost<StatsT> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • A Virtual Host that allow to alias some paths to other paths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This does not verify, when setting an alias, that the target or source exist. Neither does it check whether it's a file or a directory. Please not that directories are also renamed/replaced.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No recursion is done on the resolution, which means the following is perfectly valid then:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  host.aliases.set(normalize('/file/a'), normalize('/file/b'));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  host.aliases.set(normalize('/file/b'), normalize('/file/a'));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This will result in a proper swap of two files for each others.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const host = new SimpleMemoryHost(); host.write(normalize('/some/file'), content).subscribe();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const aHost = new AliasHost(host); aHost.read(normalize('/some/file')) .subscribe(x => expect(x).toBe(content)); aHost.aliases.set(normalize('/some/file'), normalize('/other/path');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // This file will not exist because /other/path does not exist. aHost.read(normalize('/some/file')) .subscribe(undefined, err => expect(err.message).toMatch(/does not exist/));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const host = new SimpleMemoryHost(); host.write(normalize('/some/folder/file'), content).subscribe();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const aHost = new AliasHost(host); aHost.read(normalize('/some/folder/file')) .subscribe(x => expect(x).toBe(content)); aHost.aliases.set(normalize('/some'), normalize('/other');

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // This file will not exist because /other/path does not exist. aHost.read(normalize('/some/folder/file')) .subscribe(undefined, err => expect(err.message).toMatch(/does not exist/));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  // Create the file with new content and verify that this has the new content. aHost.write(normalize('/other/folder/file'), content2).subscribe(); aHost.read(normalize('/some/folder/file')) .subscribe(x => expect(x).toBe(content2));

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly aliases: Map<Path, Path>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class CordHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class CordHost extends SimpleMemoryHost {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A Host that records changes to the underlying Host, while keeping a record of Create, Overwrite, Rename and Delete of files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is fully compatible with Host, but will keep a staging of every changes asked. That staging follows the principle of the Tree (e.g. can create a file that already exists).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Using create() and overwrite() will force those operations, but using write will add the create/overwrite records IIF the files does/doesn't already exist.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(_back: ReadonlyHost<{}>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property backend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly backend: ReadonlyHost<{}>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clone: () => CordHost;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Create a copy of this host, including all actions made.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {CordHost} The carbon copy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method commit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        commit: (host: Host, force?: boolean) => Observable<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Commit the changes recorded to a Host. It is assumed that the host does have the same structure as the host that was used for backend (could be the same host).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The host to create/delete/rename/overwrite files to.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Whether to skip existence checks when creating/overwriting. This is faster but might lead to incorrect states. Because Hosts natively don't support creation versus overwriting (it's only writing), we check for existence before completing a request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          An observable that completes when done, or error if an error occured.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        create: (path: Path, content: FileBuffer) => Observable<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specialized version of CordHost#write which forces the creation of a file whether it exists or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {Observable}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        delete: (path: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          exists: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDirectory: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFile: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                list: (path: Path) => Observable<PathFragment[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method overwrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  overwrite: (path: Path, content: FileBuffer) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    read: (path: Path) => Observable<ArrayBuffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      records: () => CordHostRecord[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rename: (from: Path, to: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stat: (path: Path) => Observable<Stats | null> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            watch: (path: Path, options?: HostWatchOptions) => null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method willCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              willCreate: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method willDelete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                willDelete: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method willOverwrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  willOverwrite: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method willRename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    willRename: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method willRenameTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      willRenameTo: (path: Path, to: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        write: (path: Path, content: FileBuffer) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Empty implements ReadonlyHost {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exists: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isDirectory: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isFile: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    list: (path: Path) => Observable<PathFragment[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      read: (path: Path) => Observable<ArrayBuffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stat: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: Path
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Observable<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isFile(): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDirectory(): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly size: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly atime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly mtime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly ctime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly birthtime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PatternMatchingHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PatternMatchingHost<StatsT extends object = {}> extends ResolverHost<StatsT> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method addPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          addPattern: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pattern: string | string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replacementFn: ReplacementFunction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ResolverHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract class ResolverHost<T extends object> implements Host<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A Host that runs a method before calling its delegate. This is an abstract class and its actual behaviour is entirely dependant of the subclass.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(_delegate: Host<T>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                delete: (path: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  exists: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDirectory: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFile: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        list: (path: Path) => Observable<PathFragment[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          read: (path: Path) => Observable<ArrayBuffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rename: (from: Path, to: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stat: (path: Path) => Observable<Stats<T> | null> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                watch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: HostWatchOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Observable<HostWatchEvent> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  write: (path: Path, content: FileBuffer) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SafeReadonlyHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SafeReadonlyHost<StatsT extends object = {}> implements ReadonlyHost<StatsT> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A Host that filters out errors. The only exception is read() which will still error out if the delegate returned an error (e.g. NodeJS will error out if the file doesn't exist).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(_delegate: ReadonlyHost<StatsT>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        exists: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDirectory: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isFile: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              list: (path: Path) => Observable<PathFragment[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                read: (path: Path) => Observable<ArrayBuffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stat: (path: Path) => Observable<Stats<StatsT> | null> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScopedHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScopedHost<T extends object> extends ResolverHost<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(delegate: Host<T>, _root?: String & { __PRIVATE_DEVKIT_PATH: void });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SimpleMemoryHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SimpleMemoryHost implements Host<{}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delete: (path: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                exists: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDirectory: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFile: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      list: (path: Path) => Observable<PathFragment[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        read: (path: Path) => Observable<ArrayBuffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rename: (from: Path, to: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reset: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stat: (path: Path) => Observable<Stats<{}> | null> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                watch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: HostWatchOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Observable<HostWatchEvent> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  write: (path: Path, content: FileBuffer) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SyncDelegateHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class SyncDelegateHost<T extends object = {}> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Implement a synchronous-only host interface (remove the Observable parts).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(_delegate: Host<T>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly delegate: Host<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: (path: Path) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            exists: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDirectory: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isFile: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  list: (path: Path) => PathFragment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    read: (path: Path) => FileBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rename: (from: Path, to: Path) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stat: (path: Path) => Stats<T> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          watch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: HostWatchOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Observable<HostWatchEvent> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            write: (path: Path, content: FileBufferLike) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class SynchronousDelegateExpectedException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class SynchronousDelegateExpectedException extends BaseException {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CordHostCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CordHostCreate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    content: FileBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: 'create';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CordHostDelete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CordHostDelete {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: 'delete';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CordHostOverwrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CordHostOverwrite {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content: FileBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    kind: 'overwrite';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CordHostRename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CordHostRename {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          from: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: 'rename';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              to: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Host<StatsT extends object = {}> extends ReadonlyHost<StatsT> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  delete: (path: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rename: (from: Path, to: Path) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      watch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: HostWatchOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Observable<HostWatchEvent> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        write: (path: Path, content: FileBufferLike) => Observable<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface HostCapabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface HostCapabilities {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property synchronous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            synchronous: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HostWatchEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HostWatchEvent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly path: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly time: Date;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly type: HostWatchEventType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HostWatchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HostWatchOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property persistent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly persistent?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property recursive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly recursive?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ReadonlyHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ReadonlyHost<StatsT extends object = {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly capabilities: HostCapabilities;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                exists: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDirectory: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFile: (path: Path) => Observable<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      list: (path: Path) => Observable<PathFragment[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        read: (path: Path) => Observable<ArrayBuffer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stat: (path: Path) => Observable<Stats<StatsT> | null> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SimpleMemoryHostStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SimpleMemoryHostStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly content: FileBuffer | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SyncHostHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SyncHostHandler<StatsT extends object = {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  delete: (path: Path) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    exists: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDirectory: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isFile: (path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          list: (path: Path) => PathFragment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            read: (path: Path) => FileBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rename: (from: Path, to: Path) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stat: (path: Path) => Stats<StatsT> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  write: (path: Path, content: FileBufferLike) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum HostWatchEventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum HostWatchEventType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Changed = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Created = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deleted = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Renamed = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Changed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Changed = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Created = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Deleted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deleted = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Renamed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Renamed = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CordHostRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CordHostRecord =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | CordHostCreate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | CordHostOverwrite
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | CordHostRename
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | CordHostDelete;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FileBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FileBuffer = ArrayBuffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FileBufferLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FileBufferLike = ArrayBufferLike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ReplacementFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ReplacementFunction = (path: Path) => Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Stats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Stats<T extends object = {}> = T & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFile(): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDirectory(): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly size: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly atime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly mtime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly ctime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly birthtime: Date;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace test

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module 'src/virtual-fs/host/test.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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TestHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class TestHost extends SimpleMemoryHost {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(map?: { [path: string]: string });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly files: Path[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property records

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly records: TestLogRecord[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly sync: SyncDelegateHost<{}>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method $exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  $exists: (path: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method $isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $isDirectory: (path: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method $isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      $isFile: (path: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method $list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        $list: (path: string) => PathFragment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method $read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          $read: (path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method $write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $write: (path: string, content: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method clearRecords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              clearRecords: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                clone: () => TestHost;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TestLogRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TestLogRecord =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'write'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'read'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'delete'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'list'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'exists'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'isDirectory'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'isFile'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'stat'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'watch';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: 'rename';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  to: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace workspaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'src/workspace/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 createWorkspaceHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createWorkspaceHost: (host: virtualFs.Host) => WorkspaceHost;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function readWorkspace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readWorkspace: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      host: WorkspaceHost,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      format?: WorkspaceFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<{ workspace: WorkspaceDefinition }>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Reads and constructs a WorkspaceDefinition. If the function is provided with a path to a directory instead of a file, a search of the directory's files will commence to attempt to locate a known workspace file. Currently the following are considered known workspace files: - angular.json - .angular.json

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The path to either a workspace file or a directory containing a workspace file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The WorkspaceHost to use to access the file and directory data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An optional WorkspaceFormat value. Used if the path specifies a non-standard file name that would prevent automatically discovering the format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An Promise of the read result object with the WorkspaceDefinition contained within the workspace property.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function writeWorkspace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeWorkspace: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      workspace: WorkspaceDefinition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      host: WorkspaceHost,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      format?: WorkspaceFormat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Writes a WorkspaceDefinition to the underlying storage via the provided WorkspaceHost. If the WorkspaceDefinition was created via the readWorkspace function, metadata will be used to determine the path and format of the Workspace. In all other cases, the path and format options must be specified as they would be otherwise unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter workspace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The WorkspaceDefinition that will be written.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The WorkspaceHost to use to access/write the file and directory data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The path to a file location for the output. Required if readWorkspace was not used to create the WorkspaceDefinition. Optional otherwise; will override the WorkspaceDefinition metadata if provided.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The WorkspaceFormat to use for output. Required if readWorkspace was not used to create the WorkspaceDefinition. Optional otherwise; will override the WorkspaceDefinition metadata if provided.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        An Promise of type void.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ProjectDefinitionCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ProjectDefinitionCollection extends DefinitionCollection<ProjectDefinition> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        initial?: Record<string, ProjectDefinition>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        listener?: DefinitionCollectionListener<ProjectDefinition>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          add: (definition: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          root: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceRoot?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          targets?: Record<string, TargetDefinition | undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }) => ProjectDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            set: (name: string, value: ProjectDefinition) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TargetDefinitionCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class TargetDefinitionCollection extends DefinitionCollection<TargetDefinition> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                initial?: Record<string, TargetDefinition>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listener?: DefinitionCollectionListener<TargetDefinition>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  add: (definition: { name: string } & TargetDefinition) => TargetDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    set: (name: string, value: TargetDefinition) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProjectDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProjectDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly extensions: Record<string, JsonValue | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            root: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sourceRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceRoot?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property targets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly targets: TargetDefinitionCollection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TargetDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TargetDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property builder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    builder: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property configurations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      configurations?: Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Record<string, JsonValue | undefined> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultConfiguration?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options?: Record<string, JsonValue | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WorkspaceDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WorkspaceDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly extensions: Record<string, JsonValue | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property projects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly projects: ProjectDefinitionCollection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WorkspaceHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WorkspaceHost {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDirectory: (path: string) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFile: (path: string) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method readFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readFile: (path: string) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method writeFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writeFile: (path: string, data: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum WorkspaceFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum WorkspaceFormat {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            JSON = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Supported workspace formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member JSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            JSON = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DefinitionCollectionListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DefinitionCollectionListener<V extends object> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              newValue: V | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              collection: DefinitionCollection<V>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (44)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@angular-devkit/core.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@angular-devkit/core)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@angular-devkit/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>