• Version 3.2.4
  • Published
  • 1.12 MB
  • 27 dependencies
  • MIT license


npm i @ionic/app-scripts
yarn add @ionic/app-scripts
pnpm add @ionic/app-scripts


Scripts for Ionic Projects







variable AT_ANGULAR

const AT_ANGULAR: string;

    variable BUILD_DIR

    const BUILD_DIR: string;

      variable BUNDLER_WEBPACK

      const BUNDLER_WEBPACK: string;

        variable COMPONENT

        const COMPONENT: string;

          variable CORDOVA

          const CORDOVA: string;

            variable DIRECTIVE

            const DIRECTIVE: string;

              variable DIRECTORY_ADD_EVENT

              const DIRECTORY_ADD_EVENT: string;

                variable DIRECTORY_DELETE_EVENT

                const DIRECTORY_DELETE_EVENT: string;


                  const ENV_ACTION_SHEET_COMPONENT_FACTORY_PATH: string;

                    variable ENV_ACTION_SHEET_COMPONENT_PATH

                    const ENV_ACTION_SHEET_COMPONENT_PATH: string;

                      variable ENV_ACTION_SHEET_CONTROLLER_CLASSNAME

                      const ENV_ACTION_SHEET_CONTROLLER_CLASSNAME: string;

                        variable ENV_ACTION_SHEET_CONTROLLER_PATH

                        const ENV_ACTION_SHEET_CONTROLLER_PATH: string;

                          variable ENV_ACTION_SHEET_VIEW_CONTROLLER_PATH

                          const ENV_ACTION_SHEET_VIEW_CONTROLLER_PATH: string;

                            variable ENV_ALERT_COMPONENT_FACTORY_PATH

                            const ENV_ALERT_COMPONENT_FACTORY_PATH: string;

                              variable ENV_ALERT_COMPONENT_PATH

                              const ENV_ALERT_COMPONENT_PATH: string;

                                variable ENV_ALERT_CONTROLLER_CLASSNAME

                                const ENV_ALERT_CONTROLLER_CLASSNAME: string;

                                  variable ENV_ALERT_CONTROLLER_PATH

                                  const ENV_ALERT_CONTROLLER_PATH: string;

                                    variable ENV_ALERT_VIEW_CONTROLLER_PATH

                                    const ENV_ALERT_VIEW_CONTROLLER_PATH: string;

                                      variable ENV_AOT_WRITE_TO_DISK

                                      const ENV_AOT_WRITE_TO_DISK: string;

                                        variable ENV_APP_ENTRY_POINT

                                        const ENV_APP_ENTRY_POINT: string;

                                          variable ENV_APP_NG_MODULE_CLASS

                                          const ENV_APP_NG_MODULE_CLASS: string;

                                            variable ENV_APP_NG_MODULE_PATH

                                            const ENV_APP_NG_MODULE_PATH: string;

                                              variable ENV_APP_ROOT_COMPONENT_PATH

                                              const ENV_APP_ROOT_COMPONENT_PATH: string;

                                                variable ENV_BAIL_ON_LINT_ERROR

                                                const ENV_BAIL_ON_LINT_ERROR: string;

                                                  variable ENV_CACHE_LOADER

                                                  const ENV_CACHE_LOADER: string;

                                                    variable ENV_CLEAN_BEFORE_COPY

                                                    const ENV_CLEAN_BEFORE_COPY: string;

                                                      variable ENV_COMPONENTS_NG_MODULE_PATH

                                                      const ENV_COMPONENTS_NG_MODULE_PATH: string;

                                                        variable ENV_DIRECTIVES_NG_MODULE_PATH

                                                        const ENV_DIRECTIVES_NG_MODULE_PATH: string;

                                                          variable ENV_DISABLE_LOGGING

                                                          const ENV_DISABLE_LOGGING: string;

                                                            variable ENV_ENABLE_LINT

                                                            const ENV_ENABLE_LINT: string;

                                                              variable ENV_GLOB_UTIL

                                                              const ENV_GLOB_UTIL: string;

                                                                variable ENV_LOADING_COMPONENT_FACTORY_PATH

                                                                const ENV_LOADING_COMPONENT_FACTORY_PATH: string;

                                                                  variable ENV_LOADING_COMPONENT_PATH

                                                                  const ENV_LOADING_COMPONENT_PATH: string;

                                                                    variable ENV_LOADING_CONTROLLER_CLASSNAME

                                                                    const ENV_LOADING_CONTROLLER_CLASSNAME: string;

                                                                      variable ENV_LOADING_CONTROLLER_PATH

                                                                      const ENV_LOADING_CONTROLLER_PATH: string;

                                                                        variable ENV_LOADING_VIEW_CONTROLLER_PATH

                                                                        const ENV_LOADING_VIEW_CONTROLLER_PATH: string;

                                                                          variable ENV_MODAL_COMPONENT_FACTORY_PATH

                                                                          const ENV_MODAL_COMPONENT_FACTORY_PATH: string;

                                                                            variable ENV_MODAL_COMPONENT_PATH

                                                                            const ENV_MODAL_COMPONENT_PATH: string;

                                                                              variable ENV_MODAL_CONTROLLER_CLASSNAME

                                                                              const ENV_MODAL_CONTROLLER_CLASSNAME: string;

                                                                                variable ENV_MODAL_CONTROLLER_PATH

                                                                                const ENV_MODAL_CONTROLLER_PATH: string;

                                                                                  variable ENV_MODAL_VIEW_CONTROLLER_PATH

                                                                                  const ENV_MODAL_VIEW_CONTROLLER_PATH: string;

                                                                                    variable ENV_NG_MODULE_FILE_NAME_SUFFIX

                                                                                    const ENV_NG_MODULE_FILE_NAME_SUFFIX: string;

                                                                                      variable ENV_OUTPUT_CSS_FILE_NAME

                                                                                      const ENV_OUTPUT_CSS_FILE_NAME: string;

                                                                                        variable ENV_OUTPUT_JS_FILE_NAME

                                                                                        const ENV_OUTPUT_JS_FILE_NAME: string;
                                                                                          const ENV_PARSE_DEEPLINKS: string;

                                                                                            variable ENV_PICKER_COMPONENT_FACTORY_PATH

                                                                                            const ENV_PICKER_COMPONENT_FACTORY_PATH: string;

                                                                                              variable ENV_PICKER_COMPONENT_PATH

                                                                                              const ENV_PICKER_COMPONENT_PATH: string;

                                                                                                variable ENV_PICKER_CONTROLLER_CLASSNAME

                                                                                                const ENV_PICKER_CONTROLLER_CLASSNAME: string;

                                                                                                  variable ENV_PICKER_CONTROLLER_PATH

                                                                                                  const ENV_PICKER_CONTROLLER_PATH: string;

                                                                                                    variable ENV_PICKER_VIEW_CONTROLLER_PATH

                                                                                                    const ENV_PICKER_VIEW_CONTROLLER_PATH: string;

                                                                                                      variable ENV_PIPES_NG_MODULE_PATH

                                                                                                      const ENV_PIPES_NG_MODULE_PATH: string;

                                                                                                        variable ENV_POLYFILL_FILE_NAME

                                                                                                        const ENV_POLYFILL_FILE_NAME: string;

                                                                                                          variable ENV_POPOVER_COMPONENT_FACTORY_PATH

                                                                                                          const ENV_POPOVER_COMPONENT_FACTORY_PATH: string;

                                                                                                            variable ENV_POPOVER_COMPONENT_PATH

                                                                                                            const ENV_POPOVER_COMPONENT_PATH: string;

                                                                                                              variable ENV_POPOVER_CONTROLLER_CLASSNAME

                                                                                                              const ENV_POPOVER_CONTROLLER_CLASSNAME: string;

                                                                                                                variable ENV_POPOVER_CONTROLLER_PATH

                                                                                                                const ENV_POPOVER_CONTROLLER_PATH: string;

                                                                                                                  variable ENV_POPOVER_VIEW_CONTROLLER_PATH

                                                                                                                  const ENV_POPOVER_VIEW_CONTROLLER_PATH: string;

                                                                                                                    variable ENV_PRINT_WEBPACK_DEPENDENCY_TREE

                                                                                                                    const ENV_PRINT_WEBPACK_DEPENDENCY_TREE: string;

                                                                                                                      variable ENV_PURGE_UNUSED_FONTS

                                                                                                                      const ENV_PURGE_UNUSED_FONTS: string;

                                                                                                                        variable ENV_READ_CONFIG_JSON

                                                                                                                        const ENV_READ_CONFIG_JSON: string;

                                                                                                                          variable ENV_SELECT_POPOVER_CLASSNAME

                                                                                                                          const ENV_SELECT_POPOVER_CLASSNAME: string;

                                                                                                                            variable ENV_SELECT_POPOVER_COMPONENT_FACTORY_PATH

                                                                                                                            const ENV_SELECT_POPOVER_COMPONENT_FACTORY_PATH: string;

                                                                                                                              variable ENV_SELECT_POPOVER_COMPONENT_PATH

                                                                                                                              const ENV_SELECT_POPOVER_COMPONENT_PATH: string;

                                                                                                                                variable ENV_SKIP_IONIC_ANGULAR_VERSION

                                                                                                                                const ENV_SKIP_IONIC_ANGULAR_VERSION: string;

                                                                                                                                  variable ENV_START_WATCH_TIMEOUT

                                                                                                                                  const ENV_START_WATCH_TIMEOUT: string;

                                                                                                                                    variable ENV_TOAST_COMPONENT_FACTORY_PATH

                                                                                                                                    const ENV_TOAST_COMPONENT_FACTORY_PATH: string;

                                                                                                                                      variable ENV_TOAST_COMPONENT_PATH

                                                                                                                                      const ENV_TOAST_COMPONENT_PATH: string;

                                                                                                                                        variable ENV_TOAST_CONTROLLER_CLASSNAME

                                                                                                                                        const ENV_TOAST_CONTROLLER_CLASSNAME: string;

                                                                                                                                          variable ENV_TOAST_CONTROLLER_PATH

                                                                                                                                          const ENV_TOAST_CONTROLLER_PATH: string;

                                                                                                                                            variable ENV_TOAST_VIEW_CONTROLLER_PATH

                                                                                                                                            const ENV_TOAST_VIEW_CONTROLLER_PATH: string;

                                                                                                                                              variable ENV_TS_CONFIG

                                                                                                                                              const ENV_TS_CONFIG: string;

                                                                                                                                                variable ENV_TYPE_CHECK_ON_LINT

                                                                                                                                                const ENV_TYPE_CHECK_ON_LINT: string;

                                                                                                                                                  variable ENV_VAR_ANGULAR_CORE_DIR

                                                                                                                                                  const ENV_VAR_ANGULAR_CORE_DIR: string;

                                                                                                                                                    variable ENV_VAR_APP_SCRIPTS_DIR

                                                                                                                                                    const ENV_VAR_APP_SCRIPTS_DIR: string;

                                                                                                                                                      variable ENV_VAR_BUILD_DIR

                                                                                                                                                      const ENV_VAR_BUILD_DIR: string;

                                                                                                                                                        variable ENV_VAR_COMPONENTS_DIR

                                                                                                                                                        const ENV_VAR_COMPONENTS_DIR: string;

                                                                                                                                                          variable ENV_VAR_CORE_COMPILER_FILE_PATH

                                                                                                                                                          const ENV_VAR_CORE_COMPILER_FILE_PATH: string;

                                                                                                                                                            variable ENV_VAR_CORE_DIR

                                                                                                                                                            const ENV_VAR_CORE_DIR: string;
                                                                                                                                                              const ENV_VAR_DEEPLINKS_DIR: string;

                                                                                                                                                                variable ENV_VAR_DEV

                                                                                                                                                                const ENV_VAR_DEV: string;

                                                                                                                                                                  variable ENV_VAR_DIRECTIVES_DIR

                                                                                                                                                                  const ENV_VAR_DIRECTIVES_DIR: string;

                                                                                                                                                                    variable ENV_VAR_FONTS_DIR

                                                                                                                                                                    const ENV_VAR_FONTS_DIR: string;

                                                                                                                                                                      variable ENV_VAR_GENERATE_SOURCE_MAP

                                                                                                                                                                      const ENV_VAR_GENERATE_SOURCE_MAP: string;

                                                                                                                                                                        variable ENV_VAR_HTML_TO_SERVE

                                                                                                                                                                        const ENV_VAR_HTML_TO_SERVE: string;

                                                                                                                                                                          variable ENV_VAR_IONIC_ANGULAR_DIR

                                                                                                                                                                          const ENV_VAR_IONIC_ANGULAR_DIR: string;

                                                                                                                                                                            variable ENV_VAR_IONIC_ANGULAR_ENTRY_POINT

                                                                                                                                                                            const ENV_VAR_IONIC_ANGULAR_ENTRY_POINT: string;

                                                                                                                                                                              variable ENV_VAR_IONIC_ANGULAR_TEMPLATE_DIR

                                                                                                                                                                              const ENV_VAR_IONIC_ANGULAR_TEMPLATE_DIR: string;

                                                                                                                                                                                variable ENV_VAR_IONIC_AOT

                                                                                                                                                                                const ENV_VAR_IONIC_AOT: string;

                                                                                                                                                                                  variable ENV_VAR_IONIC_ENV

                                                                                                                                                                                  const ENV_VAR_IONIC_ENV: string;

                                                                                                                                                                                    variable ENV_VAR_IONIC_MINIFY_CSS

                                                                                                                                                                                    const ENV_VAR_IONIC_MINIFY_CSS: string;

                                                                                                                                                                                      variable ENV_VAR_IONIC_MINIFY_JS

                                                                                                                                                                                      const ENV_VAR_IONIC_MINIFY_JS: string;

                                                                                                                                                                                        variable ENV_VAR_IONIC_OPTIMIZE_JS

                                                                                                                                                                                        const ENV_VAR_IONIC_OPTIMIZE_JS: string;

                                                                                                                                                                                          variable ENV_VAR_MOVE_SOURCE_MAPS

                                                                                                                                                                                          const ENV_VAR_MOVE_SOURCE_MAPS: string;

                                                                                                                                                                                            variable ENV_VAR_NODE_MODULES_DIR

                                                                                                                                                                                            const ENV_VAR_NODE_MODULES_DIR: string;

                                                                                                                                                                                              variable ENV_VAR_PAGES_DIR

                                                                                                                                                                                              const ENV_VAR_PAGES_DIR: string;

                                                                                                                                                                                                variable ENV_VAR_PIPES_DIR

                                                                                                                                                                                                const ENV_VAR_PIPES_DIR: string;

                                                                                                                                                                                                  variable ENV_VAR_PLATFORM

                                                                                                                                                                                                  const ENV_VAR_PLATFORM: string;

                                                                                                                                                                                                    variable ENV_VAR_PROD

                                                                                                                                                                                                    const ENV_VAR_PROD: string;

                                                                                                                                                                                                      variable ENV_VAR_PROVIDERS_DIR

                                                                                                                                                                                                      const ENV_VAR_PROVIDERS_DIR: string;

                                                                                                                                                                                                        variable ENV_VAR_ROOT_DIR

                                                                                                                                                                                                        const ENV_VAR_ROOT_DIR: string;

                                                                                                                                                                                                          variable ENV_VAR_RXJS_DIR

                                                                                                                                                                                                          const ENV_VAR_RXJS_DIR: string;

                                                                                                                                                                                                            variable ENV_VAR_SOURCE_MAP_TYPE

                                                                                                                                                                                                            const ENV_VAR_SOURCE_MAP_TYPE: string;

                                                                                                                                                                                                              variable ENV_VAR_SOURCEMAP_DIR

                                                                                                                                                                                                              const ENV_VAR_SOURCEMAP_DIR: string;

                                                                                                                                                                                                                variable ENV_VAR_SRC_DIR

                                                                                                                                                                                                                const ENV_VAR_SRC_DIR: string;

                                                                                                                                                                                                                  variable ENV_VAR_TARGET

                                                                                                                                                                                                                  const ENV_VAR_TARGET: string;

                                                                                                                                                                                                                    variable ENV_VAR_TMP_DIR

                                                                                                                                                                                                                    const ENV_VAR_TMP_DIR: string;

                                                                                                                                                                                                                      variable ENV_VAR_TYPESCRIPT_DIR

                                                                                                                                                                                                                      const ENV_VAR_TYPESCRIPT_DIR: string;

                                                                                                                                                                                                                        variable ENV_VAR_WWW_DIR

                                                                                                                                                                                                                        const ENV_VAR_WWW_DIR: string;

                                                                                                                                                                                                                          variable ENV_WEBPACK_FACTORY

                                                                                                                                                                                                                          const ENV_WEBPACK_FACTORY: string;

                                                                                                                                                                                                                            variable ENV_WEBPACK_LOADER

                                                                                                                                                                                                                            const ENV_WEBPACK_LOADER: string;

                                                                                                                                                                                                                              variable FILE_ADD_EVENT

                                                                                                                                                                                                                              const FILE_ADD_EVENT: string;

                                                                                                                                                                                                                                variable FILE_CHANGE_EVENT

                                                                                                                                                                                                                                const FILE_CHANGE_EVENT: string;

                                                                                                                                                                                                                                  variable FILE_DELETE_EVENT

                                                                                                                                                                                                                                  const FILE_DELETE_EVENT: string;

                                                                                                                                                                                                                                    variable IONIC_ANGULAR

                                                                                                                                                                                                                                    const IONIC_ANGULAR: string;

                                                                                                                                                                                                                                      variable NODE_MODULES

                                                                                                                                                                                                                                      const NODE_MODULES: string;

                                                                                                                                                                                                                                        variable objectAssign

                                                                                                                                                                                                                                        const objectAssign: {
                                                                                                                                                                                                                                        <T, U>(target: T, source: U): T & U;
                                                                                                                                                                                                                                        <T, U, V>(target: T, source1: U, source2: V): T & U & V;
                                                                                                                                                                                                                                        <T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
                                                                                                                                                                                                                                        (target: object, ...sources: any[]): any;

                                                                                                                                                                                                                                          variable PAGE

                                                                                                                                                                                                                                          const PAGE: string;

                                                                                                                                                                                                                                            variable PIPE

                                                                                                                                                                                                                                            const PIPE: string;

                                                                                                                                                                                                                                              variable PROVIDER

                                                                                                                                                                                                                                              const PROVIDER: string;

                                                                                                                                                                                                                                                variable RXJS

                                                                                                                                                                                                                                                const RXJS: string;

                                                                                                                                                                                                                                                  variable SOURCE_MAP_TYPE_CHEAP

                                                                                                                                                                                                                                                  const SOURCE_MAP_TYPE_CHEAP: string;

                                                                                                                                                                                                                                                    variable SOURCE_MAP_TYPE_EXPENSIVE

                                                                                                                                                                                                                                                    const SOURCE_MAP_TYPE_EXPENSIVE: string;

                                                                                                                                                                                                                                                      variable SOURCEMAP_DIR

                                                                                                                                                                                                                                                      const SOURCEMAP_DIR: string;

                                                                                                                                                                                                                                                        variable SRC_DIR

                                                                                                                                                                                                                                                        const SRC_DIR: string;

                                                                                                                                                                                                                                                          variable TABS

                                                                                                                                                                                                                                                          const TABS: string;

                                                                                                                                                                                                                                                            variable TMP_DIR

                                                                                                                                                                                                                                                            const TMP_DIR: string;

                                                                                                                                                                                                                                                              variable TYPESCRIPT

                                                                                                                                                                                                                                                              const TYPESCRIPT: string;

                                                                                                                                                                                                                                                                variable WWW_DIR

                                                                                                                                                                                                                                                                const WWW_DIR: string;


                                                                                                                                                                                                                                                                  function addArgv

                                                                                                                                                                                                                                                                  addArgv: (value: string) => void;

                                                                                                                                                                                                                                                                    function build

                                                                                                                                                                                                                                                                    build: (context: BuildContext) => Promise<void>;

                                                                                                                                                                                                                                                                      function buildErrorToJson

                                                                                                                                                                                                                                                                      buildErrorToJson: (buildError: BuildError) => {
                                                                                                                                                                                                                                                                      message: string;
                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                      stack: string;
                                                                                                                                                                                                                                                                      hasBeenLogged: boolean;
                                                                                                                                                                                                                                                                      isFatal: boolean;

                                                                                                                                                                                                                                                                        function buildUpdate

                                                                                                                                                                                                                                                                        buildUpdate: (
                                                                                                                                                                                                                                                                        event: string,
                                                                                                                                                                                                                                                                        filePath: string,
                                                                                                                                                                                                                                                                        context: BuildContext
                                                                                                                                                                                                                                                                        ) => Promise<void>;

                                                                                                                                                                                                                                                                          function bundle

                                                                                                                                                                                                                                                                          bundle: (context: BuildContext, configFile?: string) => Promise<void>;

                                                                                                                                                                                                                                                                            function bundlerStrategy

                                                                                                                                                                                                                                                                            bundlerStrategy: (context: BuildContext) => string;

                                                                                                                                                                                                                                                                              function bundleUpdate

                                                                                                                                                                                                                                                                              bundleUpdate: (
                                                                                                                                                                                                                                                                              changedFiles: ChangedFile[],
                                                                                                                                                                                                                                                                              context: BuildContext
                                                                                                                                                                                                                                                                              ) => Promise<void>;

                                                                                                                                                                                                                                                                                function camelCase

                                                                                                                                                                                                                                                                                camelCase: (input: string) => string;

                                                                                                                                                                                                                                                                                  function changeExtension

                                                                                                                                                                                                                                                                                  changeExtension: (filePath: string, newExtension: string) => string;

                                                                                                                                                                                                                                                                                    function clean

                                                                                                                                                                                                                                                                                    clean: (context: BuildContext) => Promise<{}>;

                                                                                                                                                                                                                                                                                      function cleancss

                                                                                                                                                                                                                                                                                      cleancss: (context: BuildContext, configFile?: string) => Promise<void>;

                                                                                                                                                                                                                                                                                        function constantCase

                                                                                                                                                                                                                                                                                        constantCase: (input: string) => string;

                                                                                                                                                                                                                                                                                          function convertFilePathToNgFactoryPath

                                                                                                                                                                                                                                                                                          convertFilePathToNgFactoryPath: (filePath: string) => string;

                                                                                                                                                                                                                                                                                            function copy

                                                                                                                                                                                                                                                                                            copy: (context: BuildContext, configFile?: string) => Promise<void>;

                                                                                                                                                                                                                                                                                              function copyFileAsync

                                                                                                                                                                                                                                                                                              copyFileAsync: (srcPath: string, destPath: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                function copyUpdate

                                                                                                                                                                                                                                                                                                copyUpdate: (
                                                                                                                                                                                                                                                                                                changedFiles: ChangedFile[],
                                                                                                                                                                                                                                                                                                context: BuildContext
                                                                                                                                                                                                                                                                                                ) => Promise<void>;

                                                                                                                                                                                                                                                                                                  function ensureSuffix

                                                                                                                                                                                                                                                                                                  ensureSuffix: (input: string, suffix: string) => string;

                                                                                                                                                                                                                                                                                                    function escapeHtml

                                                                                                                                                                                                                                                                                                    escapeHtml: (unsafe: string) => string;

                                                                                                                                                                                                                                                                                                      function escapeStringForRegex

                                                                                                                                                                                                                                                                                                      escapeStringForRegex: (input: string) => string;

                                                                                                                                                                                                                                                                                                        function fillConfigDefaults

                                                                                                                                                                                                                                                                                                        fillConfigDefaults: (userConfigFile: string, defaultConfigFile: string) => any;

                                                                                                                                                                                                                                                                                                          function generateContext

                                                                                                                                                                                                                                                                                                          generateContext: (context?: BuildContext) => BuildContext;
                                                                                                                                                                                                                                                                                                          • Create a context object which is used by all the build tasks. Filling the config data uses the following hierarchy, which will keep going down the list until it, or if it, finds data.

                                                                                                                                                                                                                                                                                                            1) Get from the passed in context variable 2) Get from the config file set using the command-line args 3) Get from environment variable 4) Get from package.json config property 5) Get environment variables

                                                                                                                                                                                                                                                                                                            Lastly, Ionic's default configs will always fill in any data which is missing from the user's data.

                                                                                                                                                                                                                                                                                                          function generateRandomHexString

                                                                                                                                                                                                                                                                                                          generateRandomHexString: (numCharacters: number) => string;

                                                                                                                                                                                                                                                                                                            function getAppScriptsPackageJson

                                                                                                                                                                                                                                                                                                            getAppScriptsPackageJson: () => any;

                                                                                                                                                                                                                                                                                                              function getAppScriptsVersion

                                                                                                                                                                                                                                                                                                              getAppScriptsVersion: () => string;

                                                                                                                                                                                                                                                                                                                function getBooleanPropertyValue

                                                                                                                                                                                                                                                                                                                getBooleanPropertyValue: (propertyName: string) => boolean;

                                                                                                                                                                                                                                                                                                                  function getConfigValue

                                                                                                                                                                                                                                                                                                                  getConfigValue: (
                                                                                                                                                                                                                                                                                                                  context: BuildContext,
                                                                                                                                                                                                                                                                                                                  argFullName: string,
                                                                                                                                                                                                                                                                                                                  argShortName: string,
                                                                                                                                                                                                                                                                                                                  envVarName: string,
                                                                                                                                                                                                                                                                                                                  packageConfigProp: string,
                                                                                                                                                                                                                                                                                                                  defaultValue: string
                                                                                                                                                                                                                                                                                                                  ) => any;

                                                                                                                                                                                                                                                                                                                    function getContext

                                                                                                                                                                                                                                                                                                                    getContext: () => BuildContext;

                                                                                                                                                                                                                                                                                                                      function getDeepLinkData

                                                                                                                                                                                                                                                                                                                      getDeepLinkData: (
                                                                                                                                                                                                                                                                                                                      appNgModuleFilePath: string,
                                                                                                                                                                                                                                                                                                                      fileCache: FileCache,
                                                                                                                                                                                                                                                                                                                      isAot: boolean
                                                                                                                                                                                                                                                                                                                      ) => Map<string, DeepLinkConfigEntry>;

                                                                                                                                                                                                                                                                                                                        function getIntPropertyValue

                                                                                                                                                                                                                                                                                                                        getIntPropertyValue: (propertyName: string) => number;

                                                                                                                                                                                                                                                                                                                          function getNgModules

                                                                                                                                                                                                                                                                                                                          getNgModules: (context: BuildContext, types: string[]) => Promise<GlobResult[]>;

                                                                                                                                                                                                                                                                                                                            function getNodeBinExecutable

                                                                                                                                                                                                                                                                                                                            getNodeBinExecutable: (context: BuildContext, cmd: string) => string;

                                                                                                                                                                                                                                                                                                                              function getPackageJsonConfig

                                                                                                                                                                                                                                                                                                                              getPackageJsonConfig: (context: BuildContext, key: string) => any;

                                                                                                                                                                                                                                                                                                                                function getParsedDeepLinkConfig

                                                                                                                                                                                                                                                                                                                                getParsedDeepLinkConfig: () => Map<string, DeepLinkConfigEntry>;

                                                                                                                                                                                                                                                                                                                                  function getProcessEnvVar

                                                                                                                                                                                                                                                                                                                                  getProcessEnvVar: (key: string) => any;

                                                                                                                                                                                                                                                                                                                                    function getStringPropertyValue

                                                                                                                                                                                                                                                                                                                                    getStringPropertyValue: (propertyName: string) => string;

                                                                                                                                                                                                                                                                                                                                      function getSystemData

                                                                                                                                                                                                                                                                                                                                      getSystemData: (userRootDir: string) => {
                                                                                                                                                                                                                                                                                                                                      ionicAppScripts: string;
                                                                                                                                                                                                                                                                                                                                      ionicFramework: string;
                                                                                                                                                                                                                                                                                                                                      ionicNative: string;
                                                                                                                                                                                                                                                                                                                                      angularCore: string;
                                                                                                                                                                                                                                                                                                                                      angularCompilerCli: string;
                                                                                                                                                                                                                                                                                                                                      node: string;
                                                                                                                                                                                                                                                                                                                                      osName: any;

                                                                                                                                                                                                                                                                                                                                        function getSystemText

                                                                                                                                                                                                                                                                                                                                        getSystemText: (userRootDir: string) => string[];

                                                                                                                                                                                                                                                                                                                                          function getUserConfigFile

                                                                                                                                                                                                                                                                                                                                          getUserConfigFile: (
                                                                                                                                                                                                                                                                                                                                          context: BuildContext,
                                                                                                                                                                                                                                                                                                                                          task: TaskInfo,
                                                                                                                                                                                                                                                                                                                                          userConfigFile: string
                                                                                                                                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                                                                                                                                            function hasArg

                                                                                                                                                                                                                                                                                                                                            hasArg: (fullName: string, shortName?: string) => boolean;

                                                                                                                                                                                                                                                                                                                                              function hasConfigValue

                                                                                                                                                                                                                                                                                                                                              hasConfigValue: (
                                                                                                                                                                                                                                                                                                                                              context: BuildContext,
                                                                                                                                                                                                                                                                                                                                              argFullName: string,
                                                                                                                                                                                                                                                                                                                                              argShortName: string,
                                                                                                                                                                                                                                                                                                                                              envVarName: string,
                                                                                                                                                                                                                                                                                                                                              defaultValue: boolean
                                                                                                                                                                                                                                                                                                                                              ) => boolean;

                                                                                                                                                                                                                                                                                                                                                function isDebugMode

                                                                                                                                                                                                                                                                                                                                                isDebugMode: () => boolean;

                                                                                                                                                                                                                                                                                                                                                  function jsonToBuildError

                                                                                                                                                                                                                                                                                                                                                  jsonToBuildError: (nonTypedBuildError: any) => BuildError;

                                                                                                                                                                                                                                                                                                                                                    function lint

                                                                                                                                                                                                                                                                                                                                                    lint: (
                                                                                                                                                                                                                                                                                                                                                    context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                    tsLintConfig?: string | null,
                                                                                                                                                                                                                                                                                                                                                    typeCheck?: boolean
                                                                                                                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                      function listOptions

                                                                                                                                                                                                                                                                                                                                                      listOptions: () => GeneratorOption[];

                                                                                                                                                                                                                                                                                                                                                        function minify

                                                                                                                                                                                                                                                                                                                                                        minify: (context: BuildContext) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                          function mkDirpAsync

                                                                                                                                                                                                                                                                                                                                                          mkDirpAsync: (directoryPath: string) => Promise<{}>;

                                                                                                                                                                                                                                                                                                                                                            function ngc

                                                                                                                                                                                                                                                                                                                                                            ngc: (context: BuildContext, configFile?: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                              function paramCase

                                                                                                                                                                                                                                                                                                                                                              paramCase: (input: string) => string;

                                                                                                                                                                                                                                                                                                                                                                function pascalCase

                                                                                                                                                                                                                                                                                                                                                                pascalCase: (input: string) => string;

                                                                                                                                                                                                                                                                                                                                                                  function printDependencyMap

                                                                                                                                                                                                                                                                                                                                                                  printDependencyMap: (map: Map<string, Set<string>>) => void;

                                                                                                                                                                                                                                                                                                                                                                    function processComponentRequest

                                                                                                                                                                                                                                                                                                                                                                    processComponentRequest: (
                                                                                                                                                                                                                                                                                                                                                                    context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                    name: string,
                                                                                                                                                                                                                                                                                                                                                                    ngModulePath: string
                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                      function processDirectiveRequest

                                                                                                                                                                                                                                                                                                                                                                      processDirectiveRequest: (
                                                                                                                                                                                                                                                                                                                                                                      context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                      ngModulePath: string
                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                        function processPageRequest

                                                                                                                                                                                                                                                                                                                                                                        processPageRequest: (
                                                                                                                                                                                                                                                                                                                                                                        context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                                                                                                        commandOptions?: { module?: boolean; constants?: boolean }
                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<string[]>;

                                                                                                                                                                                                                                                                                                                                                                          function processPipeRequest

                                                                                                                                                                                                                                                                                                                                                                          processPipeRequest: (
                                                                                                                                                                                                                                                                                                                                                                          context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                                                                                                                                                                                          ngModulePath: string
                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                            function processProviderRequest

                                                                                                                                                                                                                                                                                                                                                                            processProviderRequest: (
                                                                                                                                                                                                                                                                                                                                                                            context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                                                                            ngModulePath: string
                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                              function processStatsImpl

                                                                                                                                                                                                                                                                                                                                                                              processStatsImpl: (webpackStats: WebpackStats) => Map<string, Set<string>>;

                                                                                                                                                                                                                                                                                                                                                                                function processTabsRequest

                                                                                                                                                                                                                                                                                                                                                                                processTabsRequest: (
                                                                                                                                                                                                                                                                                                                                                                                context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                                name: string,
                                                                                                                                                                                                                                                                                                                                                                                tabs: any[],
                                                                                                                                                                                                                                                                                                                                                                                commandOptions?: { module?: boolean; constants?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                  function purgeWebpackPrefixFromPath

                                                                                                                                                                                                                                                                                                                                                                                  purgeWebpackPrefixFromPath: (filePath: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                    function rangeReplace

                                                                                                                                                                                                                                                                                                                                                                                    rangeReplace: (
                                                                                                                                                                                                                                                                                                                                                                                    source: string,
                                                                                                                                                                                                                                                                                                                                                                                    startIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                    endIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                    newContent: string
                                                                                                                                                                                                                                                                                                                                                                                    ) => string;

                                                                                                                                                                                                                                                                                                                                                                                      function readAndCacheFile

                                                                                                                                                                                                                                                                                                                                                                                      readAndCacheFile: (filePath: string, purge?: boolean) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                        function readDirAsync

                                                                                                                                                                                                                                                                                                                                                                                        readDirAsync: (pathToDir: string) => Promise<string[]>;

                                                                                                                                                                                                                                                                                                                                                                                          function readFileAsync

                                                                                                                                                                                                                                                                                                                                                                                          readFileAsync: (filePath: string) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                            function readJsonAsync

                                                                                                                                                                                                                                                                                                                                                                                            readJsonAsync: (filePath: string) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                              function removeCaseFromString

                                                                                                                                                                                                                                                                                                                                                                                              removeCaseFromString: (input: string, inReplacement?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                function removeSuffix

                                                                                                                                                                                                                                                                                                                                                                                                removeSuffix: (input: string, suffix: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                  function replaceAll

                                                                                                                                                                                                                                                                                                                                                                                                  replaceAll: (input: string, toReplace: string, replacement: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                    function replacePathVars

                                                                                                                                                                                                                                                                                                                                                                                                    replacePathVars: (
                                                                                                                                                                                                                                                                                                                                                                                                    context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                                                    filePath: string | string[] | { [key: string]: any }
                                                                                                                                                                                                                                                                                                                                                                                                    ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                      function rimRafAsync

                                                                                                                                                                                                                                                                                                                                                                                                      rimRafAsync: (directoryPath: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                        function run

                                                                                                                                                                                                                                                                                                                                                                                                        run: (task: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          function sass

                                                                                                                                                                                                                                                                                                                                                                                                          sass: (context: BuildContext, configFile?: string) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                            function sassUpdate

                                                                                                                                                                                                                                                                                                                                                                                                            sassUpdate: (
                                                                                                                                                                                                                                                                                                                                                                                                            changedFiles: ChangedFile[],
                                                                                                                                                                                                                                                                                                                                                                                                            context: BuildContext
                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                              function semverStringToObject

                                                                                                                                                                                                                                                                                                                                                                                                              semverStringToObject: (semverString: string) => SemverVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                function sentenceCase

                                                                                                                                                                                                                                                                                                                                                                                                                sentenceCase: (input: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                  function serve

                                                                                                                                                                                                                                                                                                                                                                                                                  serve: (context: BuildContext) => Promise<ServeConfig>;

                                                                                                                                                                                                                                                                                                                                                                                                                    function setAppPackageJsonData

                                                                                                                                                                                                                                                                                                                                                                                                                    setAppPackageJsonData: (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      function setContext

                                                                                                                                                                                                                                                                                                                                                                                                                      setContext: (context: BuildContext) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        function setCwd

                                                                                                                                                                                                                                                                                                                                                                                                                        setCwd: (cwd: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          function setParsedDeepLinkConfig

                                                                                                                                                                                                                                                                                                                                                                                                                          setParsedDeepLinkConfig: (map: Map<string, DeepLinkConfigEntry>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            function setProcessArgs

                                                                                                                                                                                                                                                                                                                                                                                                                            setProcessArgs: (argv: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              function setProcessEnv

                                                                                                                                                                                                                                                                                                                                                                                                                              setProcessEnv: (env: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                function setProcessEnvVar

                                                                                                                                                                                                                                                                                                                                                                                                                                setProcessEnvVar: (key: string, value: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function snakeCase

                                                                                                                                                                                                                                                                                                                                                                                                                                  snakeCase: (input: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function splitLineBreaks

                                                                                                                                                                                                                                                                                                                                                                                                                                    splitLineBreaks: (sourceText: string) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      function stringSplice

                                                                                                                                                                                                                                                                                                                                                                                                                                      stringSplice: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                      startIndex: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                      numToDelete: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                      newContent: string
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function titleCase

                                                                                                                                                                                                                                                                                                                                                                                                                                        titleCase: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function toUnixPath

                                                                                                                                                                                                                                                                                                                                                                                                                                          toUnixPath: (filePath: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function transformSrcPathToTmpPath

                                                                                                                                                                                                                                                                                                                                                                                                                                            transformSrcPathToTmpPath: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            originalPath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                            context: BuildContext
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function transformTmpPathToSrcPath

                                                                                                                                                                                                                                                                                                                                                                                                                                              transformTmpPathToSrcPath: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              originalPath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                              context: BuildContext
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function transpile

                                                                                                                                                                                                                                                                                                                                                                                                                                                transpile: (context: BuildContext) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function uglifyjs

                                                                                                                                                                                                                                                                                                                                                                                                                                                  uglifyjs: (context: BuildContext, configFile?: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function unlinkAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                    unlinkAsync: (filePath: string | string[]) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function upperCaseFirst

                                                                                                                                                                                                                                                                                                                                                                                                                                                      upperCaseFirst: (input: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                        watch: (context?: BuildContext, configFile?: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function webpackStatsToDependencyMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                          webpackStatsToDependencyMap: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          context: BuildContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          stats: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Map<string, Set<string>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function writeFileAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                            writeFileAsync: (filePath: string, content: string) => Promise<{}>;


                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AppNgModuleInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AppNgModuleInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property absolutePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                absolutePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  className: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BuildContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BuildContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property angularCoreDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      angularCoreDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property angularVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        angularVersion?: SemverVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property appNgModulePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          appNgModulePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property buildDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            buildDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bundledFilePaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bundledFilePaths?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bundler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bundler?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bundleState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bundleState?: BuildState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property componentsDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentsDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property componentsNgModulePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentsNgModulePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property coreCompilerFilePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        coreCompilerFilePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property coreDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          coreDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property deepLinkState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deepLinkState?: BuildState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property directivesDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              directivesDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property directivesNgModulePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                directivesNgModulePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fileCache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fileCache?: FileCache;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inlineTemplates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inlineTemplates?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ionicAngularDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ionicAngularDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ionicAngularVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ionicAngularVersion?: SemverVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ionicGlobal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ionicGlobal?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isProd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isProd?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isWatch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property moduleFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                moduleFiles?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property nodeModulesDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nodeModulesDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optimizeJs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optimizeJs?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property outputCssFileName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      outputCssFileName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property outputJsFileName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        outputJsFileName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pagesDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pagesDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pipesDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pipesDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pipesNgModulePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pipesNgModulePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                platform?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property providersDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  providersDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rootDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rootDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property runAot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      runAot?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property runMinifyCss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        runMinifyCss?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property runMinifyJs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          runMinifyJs?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sassState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sassState?: BuildState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sourcemapDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourcemapDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property srcDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                srcDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  target?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property templateState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    templateState?: BuildState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tmpDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tmpDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transpileState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        transpileState?: BuildState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property typescriptDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typescriptDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property typescriptVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typescriptVersion?: SemverVersion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property webpackWatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              webpackWatch?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property wwwDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wwwDir?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property wwwIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  wwwIndex?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BuildUpdateMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BuildUpdateMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property buildId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buildId: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property reloadApp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reloadApp: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ChangedFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ChangedFile {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            event: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ext: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property filePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CodegenOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CodegenOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property angularCompilerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    angularCompilerOptions: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cliOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cliOptions: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property compilerHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        compilerHost: CompilerHost;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property compilerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          compilerOptions: CompilerOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            program: Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CoreCompiler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CoreCompiler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bundle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bundle: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (config: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                srcDir: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                destDir: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                packages: Packages;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                debug?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }): Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeepLinkConfigEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeepLinkConfigEntry extends DeepLinkDecoratorAndClass, DeepLinkPathInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeepLinkDecoratorAndClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DeepLinkDecoratorAndClass {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      className: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultHistory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultHistory: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property priority

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            priority: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property rawString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rawString: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property segment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                segment: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeepLinkPathInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DeepLinkPathInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property absolutePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    absolutePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      className: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property userlandModulePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        userlandModulePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Diagnostic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Diagnostic {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property absFileName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            absFileName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                header: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  language: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    level: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property lines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      lines: PrintLine[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property messageText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        messageText: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property relFileName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          relFileName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface File

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface File {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                content: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timestamp?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FileSystem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface FileSystem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSync: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method mkdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mkdir: (filePath: string, callback: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method mkdirp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mkdirp: (filePath: string, callback: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method purge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              purge: (what: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method readdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readdir: (path: string, callback: Function) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method readFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readFile: (path: string, callback: Function) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method readJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readJson: (path: string, callback: Function) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readlink: (path: string, callback: Function) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method rmdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rmdir: (filePath: string, callback: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stat: (path: string, callback: Function) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unlink: (filePath: string, callback: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method writeFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              writeFile: (filePath: string, fileContent: Buffer, callback: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GeneratorOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface GeneratorOption {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property multiple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  multiple: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GeneratorRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GeneratorRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property includeNgModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        includeNgModule?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property includeSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeSpec?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MagicString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface MagicString {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method overwrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  overwrite: (startIndex: number, endIndex: number, newContent: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method prependLeft

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prependLeft: (index: number, contentToPrepend: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Packages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Packages {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fs?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property nodeSass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nodeSass?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property rollup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rollup?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property typescript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typescript?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property uglify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    uglify?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PrintLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PrintLine {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property errorCharStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errorCharStart: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property errorLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          errorLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            html: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lineIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lineIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lineNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SemverVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SemverVersion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property major

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      major: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property minor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        minor: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property patch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          patch: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TaskInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TaskInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultConfigFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              defaultConfigFile: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property envVar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                envVar: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fullArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fullArg: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property packageConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    packageConfig: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property shortArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shortArg: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TreeShakeCalcResults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TreeShakeCalcResults {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property purgedModules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          purgedModules: Map<string, Set<string>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property updatedDependencyMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            updatedDependencyMap: Map<string, Set<string>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface VirtualFileSystem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface VirtualFileSystem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addVirtualFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addVirtualFile: (filePath: string, fileContent: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getAllDirStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getAllDirStats: () => { [filePath: string]: VirtualDirStats };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getAllFileStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getAllFileStats: () => { [filePath: string]: VirtualFileStats };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDirectoryStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDirectoryStats: (path: string) => VirtualDirStats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getFileContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getFileContent: (filePath: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getFileNamesInDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getFileNamesInDirectory: (directoryPath: string) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getSubDirs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getSubDirs: (directoryPath: string) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WebpackDependency

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WebpackDependency {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property moduleIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                moduleIdentifier: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WebpackModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface WebpackModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    identifier: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property reasons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reasons: WebpackDependency[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WebpackStats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WebpackStats {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property modules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          modules: WebpackModule[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WorkerMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface WorkerMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context?: BuildContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                error?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pid?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property reject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reject?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolve?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property taskModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        taskModule?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property taskWorker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          taskWorker?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property workerConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            workerConfig?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WorkerProcess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface WorkerProcess {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property task

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                task: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property worker

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  worker: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WsMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface WsMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property category

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      category: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum BuildState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum BuildState {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SuccessfulBuild = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RequiresUpdate = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RequiresBuild = 2,

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member RequiresBuild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RequiresBuild = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member RequiresUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RequiresUpdate = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member SuccessfulBuild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SuccessfulBuild = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (21)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (27)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (34)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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/@ionic/app-scripts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <a href="https://www.jsdocs.io/package/@ionic/app-scripts"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>