@ionic/cli-utils

  • Version 2.2.1
  • Published
  • 404 kB
  • 21 dependencies
  • MIT license

Install

npm i @ionic/cli-utils
yarn add @ionic/cli-utils
pnpm add @ionic/cli-utils

Overview

Ionic CLI Utils

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable ASSETS_DIRECTORY

const ASSETS_DIRECTORY: string;

    variable INTEGRATION_NAMES

    const INTEGRATION_NAMES: IntegrationName[];

      variable MULTI_PROJECT_TYPES

      const MULTI_PROJECT_TYPES: ProjectType[];

        variable PROJECT_FILE

        const PROJECT_FILE: string;

          variable PROJECT_TYPES

          const PROJECT_TYPES: ProjectType[];

            Functions

            function generateIonicEnvironment

            generateIonicEnvironment: (
            ctx: IonicContext,
            pargv: string[],
            env: any
            ) => Promise<{ env: IonicEnvironment; project?: IProject }>;

              function getProject

              getProject: (
              projectDir: string | undefined,
              projectName: string | undefined,
              deps: ProjectDeps
              ) => Promise<IProject | undefined>;

                function isAPIResponseError

                isAPIResponseError: (r: APIResponse) => r is APIResponseError;

                  function isAPIResponseSuccess

                  isAPIResponseSuccess: (r: APIResponse) => r is APIResponseSuccess;

                    function isApp

                    isApp: (d: object) => d is App;

                      function isAppAssociation

                      isAppAssociation: (a: object) => a is AppAssociation;

                        function isAppAssociationResponse

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

                          function isAppResponse

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

                            function isAppsResponse

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

                              function isBitbucketCloudRepoAssociation

                              isBitbucketCloudRepoAssociation: (
                              a: object
                              ) => a is BitbucketCloudRepoAssociation;

                                function isBitbucketServerRepoAssociation

                                isBitbucketServerRepoAssociation: (
                                a: object
                                ) => a is BitbucketServerRepoAssociation;

                                  function isCommand

                                  isCommand: (c: object) => c is ICommand;

                                    function isCommandPreRun

                                    isCommandPreRun: (c: ICommand) => c is CommandPreRun;

                                      function isCordovaPackageJson

                                      isCordovaPackageJson: (o: object) => o is CordovaPackageJson;

                                        function isExitCodeException

                                        isExitCodeException: (e: Error) => e is ExitCodeException;

                                          function isGithubBranch

                                          isGithubBranch: (r: object) => r is GithubBranch;

                                            function isGithubBranchListResponse

                                            isGithubBranchListResponse: (r: APIResponse) => r is Response<GithubBranch[]>;

                                              function isGithubRepo

                                              isGithubRepo: (r: object) => r is GithubRepo;

                                                function isGithubRepoAssociation

                                                isGithubRepoAssociation: (a: object) => a is GithubRepoAssociation;

                                                  function isGithubRepoListResponse

                                                  isGithubRepoListResponse: (r: APIResponse) => r is Response<GithubRepo[]>;

                                                    function isIntegrationName

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

                                                      function isLogin

                                                      isLogin: (l: object) => l is Login;

                                                        function isLoginResponse

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

                                                          function isMultiProjectConfig

                                                          isMultiProjectConfig: (configFile?: object) => configFile is MultiProjectConfig;

                                                            function isOAuthLoginResponse

                                                            isOAuthLoginResponse: (r: APIResponse) => r is Response<OAuthLogin>;

                                                              function isOrg

                                                              isOrg: (o: object) => o is Org;

                                                                function isProjectConfig

                                                                isProjectConfig: (configFile?: object) => configFile is IProjectConfig;

                                                                  function isSecurityProfile

                                                                  isSecurityProfile: (o: object) => o is SecurityProfile;

                                                                    function isSecurityProfileResponse

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

                                                                      function isSnapshot

                                                                      isSnapshot: (s: object) => s is Snapshot;

                                                                        function isSnapshotListResponse

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

                                                                          function isSnapshotResponse

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

                                                                            function isSSHKey

                                                                            isSSHKey: (k: object) => k is SSHKey;

                                                                              function isSSHKeyListResponse

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

                                                                                function isSSHKeyResponse

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

                                                                                  function isStarterManifest

                                                                                  isStarterManifest: (o: object) => o is StarterManifest;

                                                                                    function isSuperAgentError

                                                                                    isSuperAgentError: (e: Error) => e is SuperAgentError;

                                                                                      function isTreatableAilment

                                                                                      isTreatableAilment: (a: object) => a is TreatableAilment;

                                                                                        function isUser

                                                                                        isUser: (u: object) => u is User;

                                                                                          function isUserResponse

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

                                                                                            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 sourcemaps

                                                                                              sourcemaps?: boolean;

                                                                                                interface AngularGenerateOptions

                                                                                                interface AngularGenerateOptions extends GenerateOptions {}

                                                                                                  index signature

                                                                                                  [key: string]: any;

                                                                                                    interface AngularServeOptions

                                                                                                    interface AngularServeOptions extends ServeOptions {}

                                                                                                      property configuration

                                                                                                      configuration?: string;

                                                                                                        property sourcemaps

                                                                                                        sourcemaps?: 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;

                                                                                                                                                                                  interface BaseHookContext

                                                                                                                                                                                  interface BaseHookContext {}

                                                                                                                                                                                    property argv

                                                                                                                                                                                    argv: string[];

                                                                                                                                                                                      property env

                                                                                                                                                                                      env: NodeJS.ProcessEnv;

                                                                                                                                                                                        property project

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

                                                                                                                                                                                          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 ζframework.CommandMetadata<
                                                                                                                                                                                                                ζframework.CommandMetadataInput,
                                                                                                                                                                                                                CommandMetadataOption
                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                  type: 'global' | 'project';

                                                                                                                                                                                                                    interface CommandMetadataOption

                                                                                                                                                                                                                    interface CommandMetadataOption extends ζframework.CommandMetadataOption {}

                                                                                                                                                                                                                      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 '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 ζframework.PackageJson {}

                                                                                                                                                                                                                                                                      property cordova

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

                                                                                                                                                                                                                                                                        interface CreateRequestOptions

                                                                                                                                                                                                                                                                        interface CreateRequestOptions {}

                                                                                                                                                                                                                                                                          property proxy

                                                                                                                                                                                                                                                                          proxy?: string;

                                                                                                                                                                                                                                                                            property ssl

                                                                                                                                                                                                                                                                            ssl?: SSLConfig;

                                                                                                                                                                                                                                                                              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 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: ζsuperagent.SuperAgentRequest }>;

                                                                                                                                                                                                                                                                                                                                                    method paginate

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

                                                                                                                                                                                                                                                                                                                                                      interface ICommand

                                                                                                                                                                                                                                                                                                                                                      interface ICommand
                                                                                                                                                                                                                                                                                                                                                      extends ζframework.ICommand<
                                                                                                                                                                                                                                                                                                                                                      ICommand,
                                                                                                                                                                                                                                                                                                                                                      INamespace,
                                                                                                                                                                                                                                                                                                                                                      CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                      ζframework.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 ζframework.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 {}

                                                                                                                                                                                                                                                                                                                                                                            property archiveUrl

                                                                                                                                                                                                                                                                                                                                                                            readonly archiveUrl?: string;

                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                              readonly name: IntegrationName;

                                                                                                                                                                                                                                                                                                                                                                                property summary

                                                                                                                                                                                                                                                                                                                                                                                readonly summary: string;

                                                                                                                                                                                                                                                                                                                                                                                  method add

                                                                                                                                                                                                                                                                                                                                                                                  add: (opts?: IIntegrationAddOptions) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                    method disable

                                                                                                                                                                                                                                                                                                                                                                                    disable: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                      method enable

                                                                                                                                                                                                                                                                                                                                                                                      enable: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                        method getInfo

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

                                                                                                                                                                                                                                                                                                                                                                                          method personalize

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

                                                                                                                                                                                                                                                                                                                                                                                            interface IIntegrationAddOptions

                                                                                                                                                                                                                                                                                                                                                                                            interface IIntegrationAddOptions {}

                                                                                                                                                                                                                                                                                                                                                                                              property enableArgs

                                                                                                                                                                                                                                                                                                                                                                                              enableArgs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                method conflictHandler

                                                                                                                                                                                                                                                                                                                                                                                                conflictHandler: (f: string, stats: any) => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                  method onFileCreate

                                                                                                                                                                                                                                                                                                                                                                                                  onFileCreate: (f: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    interface ILogger

                                                                                                                                                                                                                                                                                                                                                                                                    interface ILogger extends ζframework.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 INamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface INamespace
                                                                                                                                                                                                                                                                                                                                                                                                                                                      extends ζframework.INamespace<
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ζframework.CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                        env: IonicEnvironment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property project

                                                                                                                                                                                                                                                                                                                                                                                                                                                          project?: IProject;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface InfoItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface InfoItem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property flair

                                                                                                                                                                                                                                                                                                                                                                                                                                                              flair?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property group

                                                                                                                                                                                                                                                                                                                                                                                                                                                                group: InfoItemGroup;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: ζframework.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 IPCMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IPCMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'telemetry';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IProject {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly config: ζframework.BaseConfig<IProjectConfig>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property directory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly directory: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property filePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly filePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly type: ProjectType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createIntegration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method detected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    detected: () => Promise<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getBuildRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBuildRunner: () => Promise<ζbuild.BuildRunner<any> | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getDistDir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getDistDir: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDocsUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDocsUrl: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getGenerateRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getGenerateRunner: () => Promise<ζgenerate.GenerateRunner<any> | undefined>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getInfo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getIntegration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getPackageJson

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getServeRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getServeRunner: () => Promise<ζ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 requireBuildRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requireBuildRunner: () => Promise<ζbuild.BuildRunner<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method requireGenerateRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              requireGenerateRunner: () => Promise<ζgenerate.GenerateRunner<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method requirePackageJson

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method requireProId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requireProId: () => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method requireServeRunner

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requireServeRunner: () => Promise<ζserve.ServeRunner<any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IProjectConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IProjectConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hooks

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property integrations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly integrations: ProjectIntegrations;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property pro_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pro_id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ssl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ssl?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cert?: 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 tokenLogin

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IShell

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IShell {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property alterPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alterPath: (path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method cmdinfo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method output

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method run

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method spawn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spawn: (command: string, args: string[], options: IShellSpawnOptions) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 protocol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protocol: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ssl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ssl?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cert: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Login

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Login {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  token: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    user: User;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MultiProjectConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MultiProjectConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultProject?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property projects

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 RepoAssociationBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RepoAssociationBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property clone_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clone_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property full_name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        full_name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property html_url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          html_url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ResolvedStarterTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ResolvedStarterTemplate extends StarterTemplate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 ssl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ssl: 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 StarterTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface StarterTemplate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: ProjectType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SuperAgentError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SuperAgentError extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                response: ζsuperagent.Response;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface User {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              email: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property oauth_identities

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  oauth_identities?: OAuthIdentity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 = ζframework.CommandInstanceInfo<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ζframework.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 &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ζframework.HydratedCommandMetadata<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ζframework.CommandMetadataInput,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CommandMetadataOption
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InfoItemGroup

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IntegrationName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IntegrationName = 'capacitor' | 'cordova';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 = ζframework.NamespaceLocateResult<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ICommand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      INamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CommandMetadata,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ζframework.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: ζsuperagent.SuperAgentRequest;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ProjectFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ProjectFile = IProjectConfig | MultiProjectConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ProjectType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ProjectType = 'angular' | 'ionic-angular' | 'ionic1' | 'custom';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RepoAssociation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RepoAssociation =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | GithubRepoAssociation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | BitbucketCloudRepoAssociation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | BitbucketServerRepoAssociation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (21)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (21)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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/cli-utils.

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