Logo for jsDocs.io

bump-cli

  • Version 2.10.1
  • Published
  • 370 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

Classes

Interfaces

Namespaces

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;
                '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>;

                                  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_name

                                            doc_name: string;

                                              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,
                                                                              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 (6)

                                                                                                        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>