ionic

  • Version 5.4.16
  • Published
  • 900 kB
  • 28 dependencies
  • MIT license

Install

npm i ionic
yarn add ionic
pnpm add ionic

Overview

A tool for creating and developing Ionic Framework mobile apps.

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable ASSETS_DIRECTORY

const ASSETS_DIRECTORY: string;

    variable INTEGRATION_NAMES

    const INTEGRATION_NAMES: IntegrationName[];

      variable PROJECT_FILE

      const PROJECT_FILE: string;

        variable PROJECT_TYPES

        const PROJECT_TYPES: ProjectType[];

          Functions

          function generateContext

          generateContext: () => Promise<IonicContext>;

            function isAPIResponseError

            isAPIResponseError: (res: any) => res is APIResponseError;

              function isAPIResponseSuccess

              isAPIResponseSuccess: (res: any) => res is APIResponseSuccess;

                function isApp

                isApp: (app: any) => app is App;

                  function isAppAssociation

                  isAppAssociation: (association: any) => association is AppAssociation;

                    function isAppAssociationResponse

                    isAppAssociationResponse: (res: APIResponse) => res is Response<AppAssociation>;

                      function isAppResponse

                      isAppResponse: (res: APIResponse) => res is Response<App>;

                        function isAppsResponse

                        isAppsResponse: (res: APIResponse) => res is Response<App[]>;

                          function isAuthConnection

                          isAuthConnection: (connection: any) => connection is AuthConnection;

                            function isAuthConnectionResponse

                            isAuthConnectionResponse: (res: APIResponse) => res is Response<AuthConnection>;

                              function isBitbucketCloudRepoAssociation

                              isBitbucketCloudRepoAssociation: (
                              association: any
                              ) => association is BitbucketCloudRepoAssociation;

                                function isBitbucketServerRepoAssociation

                                isBitbucketServerRepoAssociation: (
                                association: any
                                ) => association is BitbucketServerRepoAssociation;

                                  function isCommand

                                  isCommand: (cmd: any) => cmd is ICommand;

                                    function isCommandPreRun

                                    isCommandPreRun: (cmd: any) => cmd is CommandPreRun;

                                      function isCordovaPackageJson

                                      isCordovaPackageJson: (obj: any) => obj is CordovaPackageJson;

                                        function isExitCodeException

                                        isExitCodeException: (err: any) => err is ExitCodeException;

                                          function isGithubBranch

                                          isGithubBranch: (branch: any) => branch is GithubBranch;

                                            function isGithubBranchListResponse

                                            isGithubBranchListResponse: (res: any) => res is Response<GithubBranch[]>;

                                              function isGithubRepo

                                              isGithubRepo: (repo: any) => repo is GithubRepo;

                                                function isGithubRepoAssociation

                                                isGithubRepoAssociation: (
                                                association: any
                                                ) => association is GithubRepoAssociation;

                                                  function isGithubRepoListResponse

                                                  isGithubRepoListResponse: (res: any) => res is Response<GithubRepo[]>;

                                                    function isIntegrationName

                                                    isIntegrationName: (name: any) => name is IntegrationName;

                                                      function isLogin

                                                      isLogin: (login: any) => login is Login;

                                                        function isLoginResponse

                                                        isLoginResponse: (res: APIResponse) => res is Response<Login>;

                                                          function isMultiProjectConfig

                                                          isMultiProjectConfig: (configFile: any) => configFile is IMultiProjectConfig;

                                                            function isOAuthLogin

                                                            isOAuthLogin: (login: any) => login is OAuthLogin;

                                                              function isOAuthLoginResponse

                                                              isOAuthLoginResponse: (res: any) => res is Response<OAuthLogin>;

                                                                function isOrg

                                                                isOrg: (org: any) => org is Org;

                                                                  function isProjectConfig

                                                                  isProjectConfig: (configFile: any) => configFile is IProjectConfig;

                                                                    function isSecurityProfile

                                                                    isSecurityProfile: (obj: any) => obj is SecurityProfile;

                                                                      function isSecurityProfileResponse

                                                                      isSecurityProfileResponse: (r: APIResponse) => r is Response<SecurityProfile>;

                                                                        function isSnapshot

                                                                        isSnapshot: (snapshot: any) => snapshot is Snapshot;

                                                                          function isSnapshotListResponse

                                                                          isSnapshotListResponse: (res: APIResponse) => res is Response<Snapshot[]>;

                                                                            function isSnapshotResponse

                                                                            isSnapshotResponse: (res: APIResponse) => res is Response<Snapshot>;

                                                                              function isSSHKey

                                                                              isSSHKey: (key: any) => key is SSHKey;

                                                                                function isSSHKeyListResponse

                                                                                isSSHKeyListResponse: (res: APIResponse) => res is Response<SSHKey[]>;

                                                                                  function isSSHKeyResponse

                                                                                  isSSHKeyResponse: (res: APIResponse) => res is Response<SSHKey>;

                                                                                    function isStarterManifest

                                                                                    isStarterManifest: (obj: any) => obj is StarterManifest;

                                                                                      function isSuperAgentError

                                                                                      isSuperAgentError: (err: any) => err is SuperAgentError;

                                                                                        function isTreatableAilment

                                                                                        isTreatableAilment: (ailment: any) => ailment is TreatableAilment;

                                                                                          function isUser

                                                                                          isUser: (user: any) => user is User;

                                                                                            function isUserResponse

                                                                                            isUserResponse: (res: APIResponse) => res is Response<User>;

                                                                                              function loadExecutor

                                                                                              loadExecutor: (ctx: IonicContext, pargv: string[]) => Promise<Executor>;

                                                                                                function receive

                                                                                                receive: (msg: IPCMessage) => Promise<void>;

                                                                                                  function run

                                                                                                  run: (pargv: string[]) => Promise<void>;

                                                                                                    Interfaces

                                                                                                    interface AngularBuildOptions

                                                                                                    interface AngularBuildOptions extends BuildOptions<'angular'> {}

                                                                                                      property configuration

                                                                                                      configuration?: string;
                                                                                                      • The Angular architect configuration to use for builds.

                                                                                                        The --prod command line flag is a shortcut which translates to the 'production' configuration.

                                                                                                      property cordovaAssets

                                                                                                      cordovaAssets?: boolean;

                                                                                                        property sourcemaps

                                                                                                        sourcemaps?: boolean;

                                                                                                          property watch

                                                                                                          watch?: boolean;

                                                                                                            interface AngularGenerateOptions

                                                                                                            interface AngularGenerateOptions extends GenerateOptions {}

                                                                                                              index signature

                                                                                                              [key: string]: any;

                                                                                                                interface AngularServeOptions

                                                                                                                interface AngularServeOptions extends ServeOptions {}

                                                                                                                  property configuration

                                                                                                                  configuration?: string;

                                                                                                                    property consolelogs

                                                                                                                    consolelogs?: boolean;

                                                                                                                      property consolelogsPort

                                                                                                                      consolelogsPort?: number;

                                                                                                                        property sourcemaps

                                                                                                                        sourcemaps?: boolean;

                                                                                                                          property ssl

                                                                                                                          ssl?: boolean;

                                                                                                                            interface APIResponseError

                                                                                                                            interface APIResponseError {}

                                                                                                                              property error

                                                                                                                              error: APIResponseErrorError;

                                                                                                                                property meta

                                                                                                                                meta: APIResponseMeta;

                                                                                                                                  interface APIResponseErrorDetails

                                                                                                                                  interface APIResponseErrorDetails {}

                                                                                                                                    property error_type

                                                                                                                                    error_type: string;

                                                                                                                                      property errors

                                                                                                                                      errors: string[];

                                                                                                                                        property parameter

                                                                                                                                        parameter: string;

                                                                                                                                          interface APIResponseErrorError

                                                                                                                                          interface APIResponseErrorError {}

                                                                                                                                            property details

                                                                                                                                            details?: APIResponseErrorDetails[];
                                                                                                                                              link: string | null;

                                                                                                                                                property message

                                                                                                                                                message: string;

                                                                                                                                                  property type

                                                                                                                                                  type: string;

                                                                                                                                                    interface APIResponseMeta

                                                                                                                                                    interface APIResponseMeta {}

                                                                                                                                                      property request_id

                                                                                                                                                      request_id: string;

                                                                                                                                                        property status

                                                                                                                                                        status: number;

                                                                                                                                                          property version

                                                                                                                                                          version: string;

                                                                                                                                                            interface APIResponsePageTokenMeta

                                                                                                                                                            interface APIResponsePageTokenMeta extends APIResponseMeta {}

                                                                                                                                                              property next_page_token

                                                                                                                                                              next_page_token?: string;

                                                                                                                                                                property prev_page_token

                                                                                                                                                                prev_page_token?: string;

                                                                                                                                                                  interface APIResponseSuccess

                                                                                                                                                                  interface APIResponseSuccess {}

                                                                                                                                                                    property data

                                                                                                                                                                    data: APIResponseData;

                                                                                                                                                                      property meta

                                                                                                                                                                      meta: APIResponseMeta;

                                                                                                                                                                        interface App

                                                                                                                                                                        interface App {}

                                                                                                                                                                          property association

                                                                                                                                                                          association?: null | AppAssociation;

                                                                                                                                                                            property id

                                                                                                                                                                            id: string;

                                                                                                                                                                              property name

                                                                                                                                                                              name: string;

                                                                                                                                                                                property org

                                                                                                                                                                                org: null | Org;

                                                                                                                                                                                  property repo_url

                                                                                                                                                                                  repo_url?: string;

                                                                                                                                                                                    property slug

                                                                                                                                                                                    slug: string;

                                                                                                                                                                                      interface AppAssociation

                                                                                                                                                                                      interface AppAssociation {}

                                                                                                                                                                                        property repository

                                                                                                                                                                                        repository: RepoAssociation;

                                                                                                                                                                                          interface BaseBuildOptions

                                                                                                                                                                                          interface BaseBuildOptions {}

                                                                                                                                                                                            property '--'

                                                                                                                                                                                            '--': string[];

                                                                                                                                                                                              property engine

                                                                                                                                                                                              engine: string;

                                                                                                                                                                                                property platform

                                                                                                                                                                                                platform?: string;

                                                                                                                                                                                                  property project

                                                                                                                                                                                                  project?: string;

                                                                                                                                                                                                    property verbose

                                                                                                                                                                                                    verbose?: boolean;

                                                                                                                                                                                                      interface BaseHookContext

                                                                                                                                                                                                      interface BaseHookContext {}

                                                                                                                                                                                                        property argv

                                                                                                                                                                                                        argv: string[];

                                                                                                                                                                                                          property env

                                                                                                                                                                                                          env: NodeJS.ProcessEnv;

                                                                                                                                                                                                            property project

                                                                                                                                                                                                            project: {
                                                                                                                                                                                                            type: ProjectType;
                                                                                                                                                                                                            dir: string;
                                                                                                                                                                                                            srcDir: string;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              interface BaseStarterTemplate

                                                                                                                                                                                                              interface BaseStarterTemplate {}

                                                                                                                                                                                                                property description

                                                                                                                                                                                                                description?: string;

                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                    property projectType

                                                                                                                                                                                                                    projectType: ProjectType;

                                                                                                                                                                                                                      interface BitbucketCloudRepoAssociation

                                                                                                                                                                                                                      interface BitbucketCloudRepoAssociation extends RepoAssociationBase {}

                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                          type: 'bitbucket_cloud';

                                                                                                                                                                                                                            interface BitbucketServerRepoAssociation

                                                                                                                                                                                                                            interface BitbucketServerRepoAssociation extends RepoAssociationBase {}

                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                              id: number;

                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                type: 'bitbucket_server';

                                                                                                                                                                                                                                  interface BuildHookInput

                                                                                                                                                                                                                                  interface BuildHookInput {}

                                                                                                                                                                                                                                    property build

                                                                                                                                                                                                                                    readonly build:
                                                                                                                                                                                                                                    | AngularBuildOptions
                                                                                                                                                                                                                                    | IonicAngularBuildOptions
                                                                                                                                                                                                                                    | Ionic1BuildOptions;

                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                      readonly name: 'build:before' | 'build:after';

                                                                                                                                                                                                                                        interface BuildOptions

                                                                                                                                                                                                                                        interface BuildOptions<T extends ProjectType> extends BaseBuildOptions {}

                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                          type: T;

                                                                                                                                                                                                                                            interface CommandMetadata

                                                                                                                                                                                                                                            interface CommandMetadata
                                                                                                                                                                                                                                            extends FrameworkCommandMetadata<CommandMetadataInput, CommandMetadataOption> {}

                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                              type: 'global' | 'project';

                                                                                                                                                                                                                                                interface CommandMetadataOption

                                                                                                                                                                                                                                                interface CommandMetadataOption extends FrameworkCommandMetadataOption {}

                                                                                                                                                                                                                                                  property hint

                                                                                                                                                                                                                                                  hint?: string;

                                                                                                                                                                                                                                                    property private

                                                                                                                                                                                                                                                    private?: boolean;

                                                                                                                                                                                                                                                      interface CommandPreRun

                                                                                                                                                                                                                                                      interface CommandPreRun extends ICommand {}

                                                                                                                                                                                                                                                        method preRun

                                                                                                                                                                                                                                                        preRun: (inputs: any, options: any, metadata: any) => Promise<void>;

                                                                                                                                                                                                                                                          interface ConfigFile

                                                                                                                                                                                                                                                          interface ConfigFile {}

                                                                                                                                                                                                                                                            property 'features.ssl-commands'

                                                                                                                                                                                                                                                            'features.ssl-commands'?: boolean;

                                                                                                                                                                                                                                                              property 'git.host'

                                                                                                                                                                                                                                                              'git.host'?: string;

                                                                                                                                                                                                                                                                property 'git.port'

                                                                                                                                                                                                                                                                'git.port'?: number;

                                                                                                                                                                                                                                                                  property 'git.setup'

                                                                                                                                                                                                                                                                  'git.setup'?: boolean;

                                                                                                                                                                                                                                                                    property 'interactive'

                                                                                                                                                                                                                                                                    interactive?: boolean;

                                                                                                                                                                                                                                                                      property 'npmClient'

                                                                                                                                                                                                                                                                      npmClient: NpmClient;

                                                                                                                                                                                                                                                                        property 'org.id'

                                                                                                                                                                                                                                                                        'org.id'?: string;

                                                                                                                                                                                                                                                                          property 'proxy'

                                                                                                                                                                                                                                                                          proxy?: string;

                                                                                                                                                                                                                                                                            property 'ssl.cafile'

                                                                                                                                                                                                                                                                            'ssl.cafile'?: string | string[];

                                                                                                                                                                                                                                                                              property 'ssl.certfile'

                                                                                                                                                                                                                                                                              'ssl.certfile'?: string | string[];

                                                                                                                                                                                                                                                                                property 'ssl.keyfile'

                                                                                                                                                                                                                                                                                'ssl.keyfile'?: string | string[];

                                                                                                                                                                                                                                                                                  property 'telemetry'

                                                                                                                                                                                                                                                                                  telemetry: boolean;

                                                                                                                                                                                                                                                                                    property 'tokens.telemetry'

                                                                                                                                                                                                                                                                                    'tokens.telemetry'?: string;

                                                                                                                                                                                                                                                                                      property 'tokens.user'

                                                                                                                                                                                                                                                                                      'tokens.user'?: string;

                                                                                                                                                                                                                                                                                        property 'urls.api'

                                                                                                                                                                                                                                                                                        'urls.api'?: string;

                                                                                                                                                                                                                                                                                          property 'urls.dash'

                                                                                                                                                                                                                                                                                          'urls.dash'?: string;

                                                                                                                                                                                                                                                                                            property 'user.email'

                                                                                                                                                                                                                                                                                            'user.email'?: string;

                                                                                                                                                                                                                                                                                              property 'user.id'

                                                                                                                                                                                                                                                                                              'user.id'?: number;

                                                                                                                                                                                                                                                                                                property 'version'

                                                                                                                                                                                                                                                                                                version: string;

                                                                                                                                                                                                                                                                                                  interface CordovaPackageJson

                                                                                                                                                                                                                                                                                                  interface CordovaPackageJson extends PackageJson {}

                                                                                                                                                                                                                                                                                                    property cordova

                                                                                                                                                                                                                                                                                                    cordova: {
                                                                                                                                                                                                                                                                                                    platforms: string[];
                                                                                                                                                                                                                                                                                                    plugins: {
                                                                                                                                                                                                                                                                                                    [key: string]: unknown;
                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      interface CreateRequestOptions

                                                                                                                                                                                                                                                                                                      interface CreateRequestOptions {}

                                                                                                                                                                                                                                                                                                        property proxy

                                                                                                                                                                                                                                                                                                        proxy?: string;

                                                                                                                                                                                                                                                                                                          property ssl

                                                                                                                                                                                                                                                                                                          ssl?: SSLConfig;

                                                                                                                                                                                                                                                                                                            interface CustomBuildOptions

                                                                                                                                                                                                                                                                                                            interface CustomBuildOptions extends BuildOptions<'custom'> {}

                                                                                                                                                                                                                                                                                                              interface CustomServeOptions

                                                                                                                                                                                                                                                                                                              interface CustomServeOptions extends ServeOptions {}

                                                                                                                                                                                                                                                                                                                interface DevAppDetails

                                                                                                                                                                                                                                                                                                                interface DevAppDetails {}

                                                                                                                                                                                                                                                                                                                  property channel

                                                                                                                                                                                                                                                                                                                  channel?: string;

                                                                                                                                                                                                                                                                                                                    property commPort

                                                                                                                                                                                                                                                                                                                    commPort: number;

                                                                                                                                                                                                                                                                                                                      property interfaces

                                                                                                                                                                                                                                                                                                                      interfaces: {
                                                                                                                                                                                                                                                                                                                      address: string;
                                                                                                                                                                                                                                                                                                                      broadcast: string;
                                                                                                                                                                                                                                                                                                                      }[];

                                                                                                                                                                                                                                                                                                                        property port

                                                                                                                                                                                                                                                                                                                        port: number;

                                                                                                                                                                                                                                                                                                                          interface DoctorTreatmentStep

                                                                                                                                                                                                                                                                                                                          interface DoctorTreatmentStep extends PatientTreatmentStep {}

                                                                                                                                                                                                                                                                                                                            method treat

                                                                                                                                                                                                                                                                                                                            treat: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                              interface EnterpriseProjectIntegration

                                                                                                                                                                                                                                                                                                                              interface EnterpriseProjectIntegration extends ProjectIntegration {}

                                                                                                                                                                                                                                                                                                                                property appId

                                                                                                                                                                                                                                                                                                                                appId?: string;

                                                                                                                                                                                                                                                                                                                                  property keyId

                                                                                                                                                                                                                                                                                                                                  keyId?: number;

                                                                                                                                                                                                                                                                                                                                    property orgId

                                                                                                                                                                                                                                                                                                                                    orgId?: string;

                                                                                                                                                                                                                                                                                                                                      property productKey

                                                                                                                                                                                                                                                                                                                                      productKey?: string;

                                                                                                                                                                                                                                                                                                                                        property registries

                                                                                                                                                                                                                                                                                                                                        registries?: string[];

                                                                                                                                                                                                                                                                                                                                          interface ExitCodeException

                                                                                                                                                                                                                                                                                                                                          interface ExitCodeException extends Error {}

                                                                                                                                                                                                                                                                                                                                            property exitCode

                                                                                                                                                                                                                                                                                                                                            exitCode: number;

                                                                                                                                                                                                                                                                                                                                              interface GenerateOptions

                                                                                                                                                                                                                                                                                                                                              interface GenerateOptions {}

                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                    interface GithubBranch

                                                                                                                                                                                                                                                                                                                                                    interface GithubBranch {}

                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                        interface GithubRepo

                                                                                                                                                                                                                                                                                                                                                        interface GithubRepo {}

                                                                                                                                                                                                                                                                                                                                                          property full_name

                                                                                                                                                                                                                                                                                                                                                          full_name: string;

                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                            id: number;

                                                                                                                                                                                                                                                                                                                                                              interface GithubRepoAssociation

                                                                                                                                                                                                                                                                                                                                                              interface GithubRepoAssociation extends RepoAssociationBase {}

                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                id: number;

                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                  type: 'github';

                                                                                                                                                                                                                                                                                                                                                                    interface IAilment

                                                                                                                                                                                                                                                                                                                                                                    interface IAilment {}

                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                      readonly id: string;

                                                                                                                                                                                                                                                                                                                                                                        property implicit

                                                                                                                                                                                                                                                                                                                                                                        implicit: boolean;

                                                                                                                                                                                                                                                                                                                                                                          property projects

                                                                                                                                                                                                                                                                                                                                                                          projects?: ProjectType[];

                                                                                                                                                                                                                                                                                                                                                                            method detected

                                                                                                                                                                                                                                                                                                                                                                            detected: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                              method getMessage

                                                                                                                                                                                                                                                                                                                                                                              getMessage: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                method getTreatmentSteps

                                                                                                                                                                                                                                                                                                                                                                                getTreatmentSteps: () => Promise<PatientTreatmentStep[]>;

                                                                                                                                                                                                                                                                                                                                                                                  interface IAilmentRegistry

                                                                                                                                                                                                                                                                                                                                                                                  interface IAilmentRegistry {}

                                                                                                                                                                                                                                                                                                                                                                                    property ailments

                                                                                                                                                                                                                                                                                                                                                                                    ailments: IAilment[];

                                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                                      get: (id: string) => IAilment | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        method register

                                                                                                                                                                                                                                                                                                                                                                                        register: (ailment: IAilment) => void;

                                                                                                                                                                                                                                                                                                                                                                                          interface IClient

                                                                                                                                                                                                                                                                                                                                                                                          interface IClient {}

                                                                                                                                                                                                                                                                                                                                                                                            property config

                                                                                                                                                                                                                                                                                                                                                                                            config: IConfig;

                                                                                                                                                                                                                                                                                                                                                                                              method do

                                                                                                                                                                                                                                                                                                                                                                                              do: (req: any) => Promise<APIResponseSuccess>;

                                                                                                                                                                                                                                                                                                                                                                                                method make

                                                                                                                                                                                                                                                                                                                                                                                                make: (method: HttpMethod, path: string) => Promise<{ req: SuperAgentRequest }>;

                                                                                                                                                                                                                                                                                                                                                                                                  method paginate

                                                                                                                                                                                                                                                                                                                                                                                                  paginate: <T extends Response<object[]>>(args: PaginateArgs<T>) => IPaginator<T>;

                                                                                                                                                                                                                                                                                                                                                                                                    interface ICommand

                                                                                                                                                                                                                                                                                                                                                                                                    interface ICommand
                                                                                                                                                                                                                                                                                                                                                                                                    extends FrameworkCommand<
                                                                                                                                                                                                                                                                                                                                                                                                    ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                    INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                    CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                    CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                    CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                    > {}

                                                                                                                                                                                                                                                                                                                                                                                                      property env

                                                                                                                                                                                                                                                                                                                                                                                                      readonly env: IonicEnvironment;

                                                                                                                                                                                                                                                                                                                                                                                                        property project

                                                                                                                                                                                                                                                                                                                                                                                                        readonly project?: IProject;

                                                                                                                                                                                                                                                                                                                                                                                                          method execute

                                                                                                                                                                                                                                                                                                                                                                                                          execute: (inputs: any, options: any, metadata: any) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                            interface IConfig

                                                                                                                                                                                                                                                                                                                                                                                                            interface IConfig extends BaseConfig<ConfigFile> {}

                                                                                                                                                                                                                                                                                                                                                                                                              method getAPIUrl

                                                                                                                                                                                                                                                                                                                                                                                                              getAPIUrl: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                method getDashUrl

                                                                                                                                                                                                                                                                                                                                                                                                                getDashUrl: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                  method getGitHost

                                                                                                                                                                                                                                                                                                                                                                                                                  getGitHost: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                    method getGitPort

                                                                                                                                                                                                                                                                                                                                                                                                                    getGitPort: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                      method getHTTPConfig

                                                                                                                                                                                                                                                                                                                                                                                                                      getHTTPConfig: () => CreateRequestOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface IIntegration

                                                                                                                                                                                                                                                                                                                                                                                                                        interface IIntegration<T extends ProjectIntegration> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property archiveUrl

                                                                                                                                                                                                                                                                                                                                                                                                                          readonly archiveUrl?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property config

                                                                                                                                                                                                                                                                                                                                                                                                                            readonly config: BaseConfig<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                              readonly name: IntegrationName;

                                                                                                                                                                                                                                                                                                                                                                                                                                property summary

                                                                                                                                                                                                                                                                                                                                                                                                                                readonly summary: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method add

                                                                                                                                                                                                                                                                                                                                                                                                                                  add: (details: IntegrationAddDetails) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method disable

                                                                                                                                                                                                                                                                                                                                                                                                                                    disable: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method enable

                                                                                                                                                                                                                                                                                                                                                                                                                                      enable: (config?: T) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                        getInfo: () => Promise<InfoItem[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method isAdded

                                                                                                                                                                                                                                                                                                                                                                                                                                          isAdded: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method isEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                            isEnabled: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method personalize

                                                                                                                                                                                                                                                                                                                                                                                                                                              personalize: (details: ProjectPersonalizationDetails) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ILogger

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ILogger extends Logger {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ok

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ok: LogFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rawmsg

                                                                                                                                                                                                                                                                                                                                                                                                                                                    rawmsg: LogFn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ImageResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ImageResource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property density

                                                                                                                                                                                                                                                                                                                                                                                                                                                        density?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dest

                                                                                                                                                                                                                                                                                                                                                                                                                                                          dest: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                            height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property imageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                              imageId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property nodeAttributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nodeAttributes: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nodeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nodeName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property orientation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      orientation?: 'landscape' | 'portrait';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        platform: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property resType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resType: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ImageResourceTransformResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ImageResourceTransformResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                error?: Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property resource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resource: ImageResource;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tmpDest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tmpDest: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ImageUploadResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ImageUploadResponse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Error: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Vector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Vector: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IMultiProjectConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IMultiProjectConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property projects

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      projects: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: IProjectConfig | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface INamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface INamespace
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends FrameworkNamespace<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          env: IonicEnvironment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            project?: IProject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InfoItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface InfoItem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property flair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                flair?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  group: InfoItemGroup;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hidden

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hidden?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IntegrationAddDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IntegrationAddDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property enableArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enableArgs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  env: IonicEnvironment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property quiet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    quiet?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      root: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IntegrationAddHandlers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IntegrationAddHandlers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property conflictHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          conflictHandler?: (f: string, stats: fs.Stats) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onFileCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onFileCreate?: (f: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Ionic1BuildOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Ionic1BuildOptions extends BuildOptions<'ionic1'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Ionic1ServeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Ionic1ServeOptions extends ServeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property consolelogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  consolelogs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property livereloadPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    livereloadPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property notificationPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      notificationPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property serverlogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serverlogs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IonicAngularBuildOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IonicAngularBuildOptions extends BuildOptions<'ionic-angular'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property aot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            aot: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              env?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property minifycss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                minifycss: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minifyjs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minifyjs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property optimizejs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    optimizejs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property prod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prod: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sourcemaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourcemaps?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IonicAngularGenerateOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IonicAngularGenerateOptions extends GenerateOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property constants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constants: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property module

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IonicAngularServeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IonicAngularServeOptions extends ServeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property consolelogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  consolelogs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    env?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property livereloadPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      livereloadPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property notificationPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        notificationPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property serverlogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serverlogs: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sourcemaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourcemaps?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IonicContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IonicContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property binPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly binPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property execPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly execPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property libPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly libPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IonicEnvironment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IonicEnvironment {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly client: IClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly config: IConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ctx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly ctx: IonicContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly flags: IonicEnvironmentFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly log: ILogger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property prompt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly prompt: PromptModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly session: ISession;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property shell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly shell: IShell;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getInfo: () => Promise<InfoItem[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IonicEnvironmentFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IonicEnvironmentFlags {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property confirm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly confirm: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property interactive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly interactive: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPaginator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IPaginator<T extends Response<object[]>, S = PaginatorState>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extends IterableIterator<Promise<T>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly state: S;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IProject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly config: BaseConfig<IProjectConfig>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property details

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly details: import('./lib/project').ProjectDetailsResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property directory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly directory: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property filePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly filePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pathPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly pathPrefix: readonly string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property rootDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly rootDirectory: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly type: ProjectType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createIntegration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createIntegration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: IntegrationName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<IIntegration<ProjectIntegration>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method detected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        detected: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getBuildRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getBuildRunner: () => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          import('./lib/build').BuildRunner<any> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDistDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDistDir: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDocsUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDocsUrl: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getGenerateRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getGenerateRunner: () => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                import('./lib/generate').GenerateRunner<any> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getInfo: () => Promise<InfoItem[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getIntegration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getIntegration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: IntegrationName
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Required<ProjectIntegration> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPackageJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPackageJson: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pkgName?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<[PackageJson | undefined, string | undefined]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getServeRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getServeRunner: () => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        import('./lib/serve').ServeRunner<any> | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSourceDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSourceDir: (sourceRoot?: string) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method personalize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            personalize: (details: ProjectPersonalizationDetails) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method registerAilments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              registerAilments: (registry: IAilmentRegistry) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method requireAppflowId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requireAppflowId: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method requireBuildRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requireBuildRunner: () => Promise<import('./lib/build').BuildRunner<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method requireGenerateRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requireGenerateRunner: () => Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    import('./lib/generate').GenerateRunner<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method requireIntegration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requireIntegration: (name: IntegrationName) => Required<ProjectIntegration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method requirePackageJson

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        requirePackageJson: (pkgName?: string) => Promise<PackageJson>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method requireServeRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          requireServeRunner: () => Promise<import('./lib/serve').ServeRunner<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IProjectConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IProjectConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hooks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly hooks?: Record<HookName, string | string[] | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property integrations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly integrations: ProjectIntegrations;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      root?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: ProjectType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ISession

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ISession {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getUser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getUser: () => { id: number };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getUserToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getUserToken: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isLoggedIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isLoggedIn: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method login

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  login: (email: string, password: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method logout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    logout: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ssoLogin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ssoLogin: (email: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method tokenLogin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tokenLogin: (token: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IShell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IShell {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property alterPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            alterPath: (path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method cmdinfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cmdinfo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cmd: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              args?: readonly string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<string | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method createSubprocess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createSubprocess: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                args: readonly string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<Subprocess>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  output: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  args: readonly string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: IShellOutputOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    run: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: readonly string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: IShellRunOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method spawn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      spawn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: readonly string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: IShellSpawnOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<ChildProcess>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method which

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        which: (command: string, options?: any) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IShellOutputOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IShellOutputOptions extends IShellSpawnOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fatalOnError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fatalOnError?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fatalOnNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fatalOnNotFound?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property showError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showError?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IShellRunOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IShellRunOptions extends IShellOutputOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property killOnExit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    killOnExit?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stream?: NodeJS.WritableStream;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property truncateErrorOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        truncateErrorOutput?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IShellSpawnOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IShellSpawnOptions extends SpawnOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property showCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showCommand?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ITelemetry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ITelemetry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method sendCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sendCommand: (command: string, args: string[]) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LabServeDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LabServeDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      port: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property projectType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        projectType: ProjectType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Login

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Login {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            token: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              user: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ManagedStarterTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ManagedStarterTemplate extends BaseStarterTemplate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'managed';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OAuthIdentityDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OAuthIdentityDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property html_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        html_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OAuthLogin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface OAuthLogin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property redirect_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                redirect_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Org

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Org {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PackageVersions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PackageVersions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PagePaginatorState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PagePaginatorState extends PaginatorState {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property page

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            page: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property page_size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              page_size?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PaginatorDeps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PaginatorDeps<T extends Response<object[]>, S = PaginatorState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property client

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly client: IClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property guard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly guard: PaginatorGuard<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly max?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property reqgen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly reqgen: PaginatorRequestGenerator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly state?: Partial<S>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PaginatorState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PaginatorState {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property done

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              done: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loaded: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PatientTreatmentStep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PatientTreatmentStep {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProjectIntegration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ProjectIntegration {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          root?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ProjectIntegrations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ProjectIntegrations {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property capacitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              capacitor?: ProjectIntegration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cordova

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cordova?: ProjectIntegration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property enterprise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  enterprise?: EnterpriseProjectIntegration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ProjectPersonalizationDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ProjectPersonalizationDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property packageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          packageId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property projectId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            projectId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              version?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReactBuildOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReactBuildOptions extends BuildOptions<'react'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ci

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ci?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inlineRuntimeChunk

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inlineRuntimeChunk?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property publicUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      publicUrl?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sourceMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceMap?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReactServeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ReactServeOptions extends ServeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ci

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ci?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property https

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              https?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property reactEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reactEditor?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RepoAssociationBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RepoAssociationBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property clone_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clone_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property full_name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      full_name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property html_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        html_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RepoStarterTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RepoStarterTemplate extends BaseStarterTemplate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property repo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            repo: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'repo';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ResolvedStarterTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ResolvedStarterTemplate extends BaseStarterTemplate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property archive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  archive: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResourceClientCreate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResourceClientCreate<T extends object, U extends object> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: (details: U) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResourceClientDelete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResourceClientDelete {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          delete: (id: string | number) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ResourceClientLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ResourceClientLoad<T extends object> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              load: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              modifiers: ResourceClientRequestModifiers
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ResourceClientPaginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ResourceClientPaginate<T extends object> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method paginate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paginate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  args?: Partial<PaginateArgs<Response<T[]>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => IPaginator<Response<T[]>, PaginatorState>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResourceClientRequestModifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ResourceClientRequestModifiers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fields?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResourcesConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResourcesConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [propName: string]: ResourcesPlatform;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ResourcesImageConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ResourcesImageConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property density

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              density?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property orientation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    orientation?: 'landscape' | 'portrait';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResourcesPlatform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResourcesPlatform {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [imgType: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          images: ResourcesImageConfig[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeAttributes: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Response<T extends object> extends APIResponseSuccess {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Runner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Runner<T extends object, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  run: (options: T) => Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SecurityProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SecurityProfile {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      created: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        credentials: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        android?: object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ios?: object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tag: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'development' | 'production';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ServeAfterHookInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ServeAfterHookInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly name: 'serve:after';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property serve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly serve: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | AngularServeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | IonicAngularServeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Ionic1ServeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ServeDetails;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ServeBeforeHookInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ServeBeforeHookInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly name: 'serve:before';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property serve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly serve:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | AngularServeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | IonicAngularServeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Ionic1ServeOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServeDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServeDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property custom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              custom: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property externalAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                externalAddress: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property externallyAccessible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  externallyAccessible: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property externalNetworkInterfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    externalNetworkInterfaces: NetworkInterface[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property localAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      localAddress: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        port: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property protocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protocol: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ServeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property '--'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              '--': string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property browser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  browser?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property browserOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    browserOption?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property devapp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      devapp: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property engine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        engine: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property externalAddressRequired

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          externalAddressRequired?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property lab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lab: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property labHost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              labHost: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property labPort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                labPort: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property livereload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  livereload: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    open: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      platform?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        port: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property project

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          project?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            proxy: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property verbose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verbose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Snapshot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Snapshot {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  created: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property note

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      note: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ref: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sha

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sha: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            state: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SourceImage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SourceImage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cachedId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cachedId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ext: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property imageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      imageId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property platform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          platform: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property resType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resType: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property vector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              vector: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SSHKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SSHKey {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property annotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    annotation: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property created

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      created: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fingerprint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fingerprint: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pubkey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pubkey: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property updated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                updated: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SSLConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SSLConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cafile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cafile?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property certfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      certfile?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyfile?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StarterList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StarterList {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property integrations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            integrations: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: IntegrationName;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property starters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              starters: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: ProjectType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface StarterManifest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface StarterManifest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property baseref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseref: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property welcome

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      welcome?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SuperAgentError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SuperAgentError extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          response: import('superagent').Response;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TelemetryIPCMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TelemetryIPCMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              command: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              args: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'telemetry';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TokenPaginatorState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TokenPaginatorState extends PaginatorState {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property page_token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    page_token?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TreatableAilment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TreatableAilment extends IAilment {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property treatable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly treatable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getTreatmentSteps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getTreatmentSteps: () => Promise<DoctorTreatmentStep[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UpdateCheckIPCMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UpdateCheckIPCMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'update-check';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface User {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  email: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property oauth_identities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      oauth_identities?: OAuthIdentity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VueBuildOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VueBuildOptions extends BuildOptions<'vue'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          configuration?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property cordovaAssets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cordovaAssets?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sourcemaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourcemaps?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface VueServeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface VueServeOptions extends ServeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property configuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  configuration?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sourcemaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourcemaps?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ssl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ssl?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type APIResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type APIResponse = APIResponseSuccess | APIResponseError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type APIResponseData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type APIResponseData = object | object[] | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AssociationType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AssociationType = 'github' | 'bitbucket_cloud' | 'bitbucket_server';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CommandInstanceInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CommandInstanceInfo = FrameworkCommandInstanceInfo<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DistTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DistTag = 'testing' | 'canary' | 'latest';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FeatureId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FeatureId = 'ssl-commands';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HookContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HookContext = BaseHookContext & HookInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HookFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HookFn = (ctx: HookContext) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HookInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HookInput = BuildHookInput | ServeBeforeHookInput | ServeAfterHookInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HookName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HookName = 'build:before' | 'build:after' | 'serve:before' | 'serve:after';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HttpMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type HttpMethod =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'GET'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'POST'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PATCH'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PUT'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'DELETE'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PURGE'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'HEAD'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'OPTIONS';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HydratedCommandMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type HydratedCommandMetadata = CommandMetadata &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FrameworkHydratedCommandMetadata<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InfoItemGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InfoItemGroup =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'ionic'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'capacitor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'cordova'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'utility'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'system'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'environment';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IntegrationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type IntegrationName = 'capacitor' | 'cordova' | 'enterprise';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IPCMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type IPCMessage = TelemetryIPCMessage | UpdateCheckIPCMessage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KnownPlatform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type KnownPlatform = 'ios' | 'android' | 'wp8' | 'windows' | 'browser';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type KnownResourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type KnownResourceType = 'icon' | 'splash';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LogFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LogFn = (msg: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NamespaceLocateResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NamespaceLocateResult = FrameworkNamespaceLocateResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NpmClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NpmClient = 'yarn' | 'npm';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OAuthIdentity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OAuthIdentity = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [A in AssociationType]?: OAuthIdentityDetails;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PaginateArgs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PaginateArgs<T extends Response<object[]>> = Pick<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  PaginatorDeps<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'reqgen' | 'guard' | 'state' | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PaginatorGuard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PaginatorGuard<T extends Response<object[]>> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    res: APIResponseSuccess
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => res is T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PaginatorRequestGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PaginatorRequestGenerator = () => Promise<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      req: SuperAgentRequest;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ProjectFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ProjectFile = IProjectConfig | IMultiProjectConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ProjectType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ProjectType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'angular'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ionic-angular'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ionic1'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'custom'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'bare'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'react'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'vue';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RepoAssociation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RepoAssociation =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | GithubRepoAssociation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | BitbucketCloudRepoAssociation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | BitbucketServerRepoAssociation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StarterTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StarterTemplate = RepoStarterTemplate | ManagedStarterTemplate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SuperAgentRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SuperAgentRequest = import('superagent').SuperAgentRequest;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (28)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (22)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Badge

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ionic.

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