bump-cli

  • Version 2.12.0
  • Published
  • 424 kB
  • 14 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 APIs of developers.bump.sh

Index

Variables

variable COMMANDS

const COMMANDS: {
deploy: typeof Deploy;
diff: typeof Diff;
overlay: typeof Overlay;
preview: typeof Preview;
release: typeof Release;
unrelease: typeof Unrelease;
};

    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;
            'mcp-server': any;
            overlay: any;
            preview: 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,
              overlays?: 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,
                temporary?: boolean | undefined
                ) => Promise<void>;

                  method deploySingleWorkflowFile

                  protected deploySingleWorkflowFile: (
                  workflowDefinition: API,
                  mcpServer: string,
                  token: string
                  ) => 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>;

                                  class Release

                                  class Release extends BaseCommand<typeof Release> {}

                                    property args

                                    static args: { versionId: any };

                                      property description

                                      static description: string;

                                        property examples

                                        static examples: string[];

                                          property flags

                                          static flags: { token: any };

                                            method run

                                            run: () => Promise<void>;

                                              class Unrelease

                                              class Unrelease extends BaseCommand<typeof Unrelease> {}

                                                property args

                                                static args: { versionId: any };

                                                  property description

                                                  static description: string;

                                                    property examples

                                                    static examples: string[];

                                                      property flags

                                                      static flags: { token: any };

                                                        method run

                                                        run: () => Promise<void>;

                                                          Interfaces

                                                          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_id

                                                                    doc_id?: string;

                                                                      property doc_name

                                                                      doc_name: string;

                                                                        property doc_public_url

                                                                        doc_public_url?: string;

                                                                          property id

                                                                          id: string;

                                                                            property state

                                                                            state?: 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,
                                                                                                      overlays1?: string[] | undefined,
                                                                                                      overlays2?: 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,
                                                                                                        overlays?: string[] | undefined
                                                                                                        ) => Promise<VersionResponse | undefined>;

                                                                                                          method d

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

                                                                                                            method extractDiff

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

                                                                                                              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,
                                                                                                                    overlays1?: string[] | undefined,
                                                                                                                    overlays2?: string[] | undefined
                                                                                                                    ) => Promise<DiffResult | undefined>;

                                                                                                                      method waitResult

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

                                                                                                                        interface DiffResult

                                                                                                                        interface DiffResult extends DiffResponse {}

                                                                                                                          property doc_name

                                                                                                                          doc_name?: string;

                                                                                                                            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 (8)

                                                                                                                                    Dependencies (14)

                                                                                                                                    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>