• Version 10.0.0
  • Published
  • 61.4 kB
  • 10 dependencies
  • ISC license


npm i @heroku-cli/command
yarn add @heroku-cli/command
pnpm add @heroku-cli/command


base class for Heroku CLI commands



variable vars

const vars: Vars;


    class APIClient

    class APIClient {}


      constructor(config: Interfaces.Config, options?: IOptions);

        property auth

        auth: string;

          property authPromise

          authPromise?: Promise<HTTP<any>>;

            property config

            protected config: Interfaces.Config;

              property defaults

              readonly defaults: any;

                property http

                http: any;

                  property options

                  options: IOptions;

                    property preauthPromises

                    preauthPromises: { [k: string]: Promise<HTTP<any>> };

                      property twoFactorMutex

                      readonly twoFactorMutex: Mutex<string>;

                        method delete

                        delete: <T>(url: string, options?: APIClient.Options) => Promise<HTTP<T>>;

                          method get

                          get: <T>(url: string, options?: APIClient.Options) => Promise<HTTP<T>>;

                            method login

                            login: (opts?: Login.Options) => Promise<void>;

                              method logout

                              logout: () => Promise<void>;

                                method patch

                                patch: <T>(url: string, options?: APIClient.Options) => Promise<HTTP<T>>;

                                  method post

                                  post: <T>(url: string, options?: APIClient.Options) => Promise<HTTP<T>>;

                                    method preauth

                                    preauth: (app: string, factor: string) => Promise<HTTP<unknown>>;

                                      method put

                                      put: <T>(url: string, options?: APIClient.Options) => Promise<HTTP<T>>;

                                        method request

                                        request: <T>(url: string, options?: APIClient.Options) => Promise<HTTP<T>>;

                                          method stream

                                          stream: (url: string, options?: APIClient.Options) => Promise<HTTP<unknown>>;

                                            method twoFactorPrompt

                                            twoFactorPrompt: () => Promise<string>;

                                              class Command

                                              abstract class Command extends Base {}

                                                property base

                                                base: string;

                                                  property cli

                                                  readonly cli: any;

                                                    property heroku

                                                    readonly heroku: APIClient;

                                                      property legacyHerokuClient

                                                      readonly legacyHerokuClient: any;

                                                        property out

                                                        readonly out: any;


                                                          namespace APIClient

                                                          namespace APIClient {}

                                                            interface Options

                                                            interface Options extends HTTPRequestOptions {}

                                                              property retryAuth

                                                              retryAuth?: boolean;

                                                                namespace completions

                                                                module 'lib/completions.d.ts' {}

                                                                  variable AppAddonCompletion

                                                                  const AppAddonCompletion: Completion;

                                                                    variable AppCompletion

                                                                    const AppCompletion: Completion;

                                                                      variable AppDynoCompletion

                                                                      const AppDynoCompletion: Completion;

                                                                        variable BuildpackCompletion

                                                                        const BuildpackCompletion: Completion;

                                                                          variable DynoSizeCompletion

                                                                          const DynoSizeCompletion: Completion;

                                                                            variable FileCompletion

                                                                            const FileCompletion: Completion;

                                                                              variable oneDay

                                                                              const oneDay: number;

                                                                                variable PipelineCompletion

                                                                                const PipelineCompletion: Completion;

                                                                                  variable ProcessTypeCompletion

                                                                                  const ProcessTypeCompletion: Completion;

                                                                                    variable RegionCompletion

                                                                                    const RegionCompletion: Completion;

                                                                                      variable RemoteCompletion

                                                                                      const RemoteCompletion: Completion;

                                                                                        variable RoleCompletion

                                                                                        const RoleCompletion: Completion;

                                                                                          variable ScopeCompletion

                                                                                          const ScopeCompletion: Completion;

                                                                                            variable SpaceCompletion

                                                                                            const SpaceCompletion: Completion;

                                                                                              variable StackCompletion

                                                                                              const StackCompletion: Completion;

                                                                                                variable StageCompletion

                                                                                                const StageCompletion: Completion;

                                                                                                  variable TeamCompletion

                                                                                                  const TeamCompletion: Completion;

                                                                                                    function herokuGet

                                                                                                    herokuGet: (
                                                                                                    resource: string,
                                                                                                    ctx: { config: Interfaces.Config }
                                                                                                    ) => Promise<string[]>;

                                                                                                      namespace flags

                                                                                                      module 'lib/flags/index.d.ts' {}

                                                                                                        variable app

                                                                                                        const app: any;

                                                                                                          variable org

                                                                                                          const org: any;

                                                                                                            variable pipeline

                                                                                                            const pipeline: any;

                                                                                                              variable remote

                                                                                                              const remote: any;

                                                                                                                variable team

                                                                                                                const team: any;

                                                                                                                  Package Files (10)

                                                                                                                  Dependencies (10)

                                                                                                                  Dev Dependencies (22)

                                                                                                                  Peer Dependencies (0)

                                                                                                                  No peer dependencies.


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

                                                                                                                  You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@heroku-cli/command.

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