@heroku-cli/command

  • Version 12.0.1
  • Published
  • 82.9 kB
  • 9 dependencies
  • ISC license

Install

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

Overview

base class for Heroku CLI commands

Index

Variables

variable vars

const vars: Vars;

    Classes

    class APIClient

    class APIClient {}

      constructor

      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 particleboard

                    readonly particleboard: ParticleboardClient;

                      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 allowArbitraryFlags

                                                  allowArbitraryFlags: boolean;

                                                    property base

                                                    base: string;

                                                      property heroku

                                                      readonly heroku: APIClient;

                                                        method parse

                                                        protected parse: <
                                                        F extends FlagOutput,
                                                        B extends FlagOutput,
                                                        A extends ArgOutput
                                                        >(
                                                        options?: Input<F, B, A>,
                                                        argv?: string[]
                                                        ) => Promise<ParserOutput<F, B, A>>;

                                                          Namespaces

                                                          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: {
                                                                  cacheDuration: number;
                                                                  cacheKey(ctx: { flags: { app: any } }): Promise<string>;
                                                                  options(ctx: { config: Interfaces.Config; flags?: any }): Promise<string[]>;
                                                                  };

                                                                    variable AppCompletion

                                                                    const AppCompletion: {
                                                                    cacheDuration: number;
                                                                    options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                    };

                                                                      variable AppDynoCompletion

                                                                      const AppDynoCompletion: {
                                                                      cacheDuration: number;
                                                                      cacheKey(ctx: { flags: { app: any } }): Promise<string>;
                                                                      options(ctx: { config: Interfaces.Config; flags?: any }): Promise<string[]>;
                                                                      };

                                                                        variable BuildpackCompletion

                                                                        const BuildpackCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                          variable DynoSizeCompletion

                                                                          const DynoSizeCompletion: {
                                                                          cacheDuration: number;
                                                                          options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                          };

                                                                            variable FileCompletion

                                                                            const FileCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                              variable oneDay

                                                                              const oneDay: number;

                                                                                variable PipelineCompletion

                                                                                const PipelineCompletion: {
                                                                                cacheDuration: number;
                                                                                options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                                };

                                                                                  variable ProcessTypeCompletion

                                                                                  const ProcessTypeCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                                    variable RegionCompletion

                                                                                    const RegionCompletion: {
                                                                                    cacheDuration: number;
                                                                                    options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                                    };

                                                                                      variable RemoteCompletion

                                                                                      const RemoteCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                                        variable RoleCompletion

                                                                                        const RoleCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                                          variable ScopeCompletion

                                                                                          const ScopeCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                                            variable SpaceCompletion

                                                                                            const SpaceCompletion: {
                                                                                            cacheDuration: number;
                                                                                            options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                                            };

                                                                                              variable StackCompletion

                                                                                              const StackCompletion: {
                                                                                              cacheDuration: number;
                                                                                              options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                                              };

                                                                                                variable StageCompletion

                                                                                                const StageCompletion: { options(): Promise<string[]>; skipCache: boolean };

                                                                                                  variable TeamCompletion

                                                                                                  const TeamCompletion: {
                                                                                                  cacheDuration: number;
                                                                                                  options(ctx: { config: Interfaces.Config }): Promise<string[]>;
                                                                                                  };

                                                                                                    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 boolean

                                                                                                          const boolean: any;

                                                                                                            variable custom

                                                                                                            const custom: any;

                                                                                                              variable directory

                                                                                                              const directory: any;

                                                                                                                variable file

                                                                                                                const file: any;

                                                                                                                  variable integer

                                                                                                                  const integer: any;

                                                                                                                    variable option

                                                                                                                    const option: any;

                                                                                                                      variable org

                                                                                                                      const org: any;

                                                                                                                        variable pipeline

                                                                                                                        const pipeline: any;

                                                                                                                          variable remote

                                                                                                                          const remote: any;

                                                                                                                            variable string

                                                                                                                            const string: any;

                                                                                                                              variable team

                                                                                                                              const team: any;

                                                                                                                                variable url

                                                                                                                                const url: any;

                                                                                                                                  Package Files (10)

                                                                                                                                  Dependencies (9)

                                                                                                                                  Dev Dependencies (30)

                                                                                                                                  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/@heroku-cli/command.

                                                                                                                                  • Markdown
                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@heroku-cli/command)
                                                                                                                                  • 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>