bump-cli

  • Version 2.9.2
  • Published
  • 108 kB
  • 15 dependencies
  • MIT license

Install

npm i bump-cli
yarn add bump-cli
pnpm add bump-cli

Overview

The Bump CLI is used to interact with your API documentation hosted on Bump.sh by using the API of developers.bump.sh

Index

Variables

variable COMMANDS

const COMMANDS: {
deploy: typeof Deploy;
diff: typeof Diff;
overlay: typeof Overlay;
preview: typeof Preview;
};

    Classes

    class Deploy

    class Deploy extends BaseCommand<typeof Deploy> {}

      property args

      static args: { file: any };

        property description

        static description: string;

          property examples

          static examples: string[];

            property flags

            static flags: {
            'auto-create': any;
            branch: any;
            doc: any;
            'doc-name': any;
            'dry-run': any;
            'filename-pattern': any;
            hub: any;
            interactive: any;
            overlay: any;
            token: any;
            };

              method deployDirectory

              protected deployDirectory: (
              dir: string,
              dryRun: boolean,
              token: string,
              hub: string,
              autoCreate: boolean,
              interactive: boolean,
              filenamePattern: string,
              documentationName: string | undefined,
              branch: string | undefined
              ) => Promise<void>;

                method deploySingleFile

                protected deploySingleFile: (
                api: API,
                dryRun: boolean,
                documentation: string,
                token: string,
                hub: string | undefined,
                autoCreate: boolean,
                documentationName: string | undefined,
                branch: string | undefined,
                overlay?: string[] | undefined
                ) => Promise<void>;

                  method run

                  run: () => Promise<void>;

                    class Preview

                    class Preview extends BaseCommand<typeof Preview> {}

                      property args

                      static args: { file: any };

                        property description

                        static description: string;

                          property examples

                          static examples: string[];

                            property flags

                            static flags: { live: any; open: any };

                              method run

                              run: () => Promise<void>;

                                Interfaces

                                interface DiffResponse

                                interface DiffResponse {}

                                  property breaking

                                  breaking?: boolean;

                                    property details

                                    details?: DiffItem[];

                                      property html

                                      html?: string;

                                        property id

                                        id: string;

                                          property markdown

                                          markdown?: string;

                                            property public_url

                                            public_url?: string;

                                              property text

                                              text?: string;

                                                interface PreviewResponse

                                                interface PreviewResponse {}

                                                  property expires_at

                                                  expires_at?: string;

                                                    property id

                                                    id: string;

                                                      property public_url

                                                      public_url?: string;

                                                        interface VersionResponse

                                                        interface VersionResponse {}

                                                          property doc_public_url

                                                          doc_public_url?: string;

                                                            property id

                                                            id: string;

                                                              interface WithDiff

                                                              interface WithDiff {}

                                                                property diff_breaking

                                                                diff_breaking?: boolean;

                                                                  property diff_details

                                                                  diff_details?: DiffItem[];

                                                                    property diff_markdown

                                                                    diff_markdown?: string;

                                                                      property diff_public_url

                                                                      diff_public_url?: string;

                                                                        property diff_summary

                                                                        diff_summary?: string;

                                                                          Namespaces

                                                                          namespace Diff

                                                                          module 'dist/core/diff.d.ts' {}

                                                                            class Diff

                                                                            class Diff {}

                                                                              constructor

                                                                              constructor(config?: Config);

                                                                                property bumpClient

                                                                                readonly bumpClient: BumpApi;

                                                                                  property pollingPeriod

                                                                                  readonly pollingPeriod: number;

                                                                                    property TIMEOUT

                                                                                    static readonly TIMEOUT: number;

                                                                                      method createDiff

                                                                                      createDiff: (
                                                                                      file1: string,
                                                                                      file2: string,
                                                                                      expires: string | undefined
                                                                                      ) => Promise<DiffResponse | undefined>;

                                                                                        method createVersion

                                                                                        createVersion: (
                                                                                        file: string,
                                                                                        documentation: string,
                                                                                        token: string,
                                                                                        hub: string | undefined,
                                                                                        branch_name: string | undefined,
                                                                                        previous_version_id?: string | undefined
                                                                                        ) => Promise<VersionResponse | undefined>;

                                                                                          method d

                                                                                          d: (formatter: any, ...args: any[]) => void;

                                                                                            method extractDiff

                                                                                            extractDiff: (versionWithDiff: VersionResponse & WithDiff) => DiffResponse;

                                                                                              method isVersion

                                                                                              isVersion: (result: DiffResponse | VersionResponse) => result is VersionResponse;

                                                                                                method isVersionWithDiff

                                                                                                isVersionWithDiff: (
                                                                                                result: DiffResponse | (VersionResponse & WithDiff)
                                                                                                ) => result is VersionResponse & WithDiff;

                                                                                                  method pollingDelay

                                                                                                  pollingDelay: () => Promise<void>;

                                                                                                    method run

                                                                                                    run: (
                                                                                                    file1: string,
                                                                                                    file2: string | undefined,
                                                                                                    documentation: string | undefined,
                                                                                                    hub: string | undefined,
                                                                                                    branch: string | undefined,
                                                                                                    token: string | undefined,
                                                                                                    format: string,
                                                                                                    expires: string | undefined
                                                                                                    ) => Promise<DiffResponse | undefined>;

                                                                                                      method waitResult

                                                                                                      waitResult: (
                                                                                                      result: DiffResponse | VersionResponse,
                                                                                                      token: string | undefined,
                                                                                                      opts: { format: string; timeout: number }
                                                                                                      ) => Promise<DiffResponse>;

                                                                                                        namespace Overlay

                                                                                                        module 'dist/core/overlay.d.ts' {}

                                                                                                          class Overlay

                                                                                                          class Overlay {}

                                                                                                            method d

                                                                                                            d: (formatter: any, ...args: any[]) => void;

                                                                                                              method run

                                                                                                              run: (spec: APIDefinition, overlay: OpenAPIOverlay) => APIDefinition;

                                                                                                                Package Files (6)

                                                                                                                Dependencies (15)

                                                                                                                Dev Dependencies (25)

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

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