Logo for jsDocs.io

bump-cli

  • Version 2.9.12
  • Published
  • 329 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 API 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 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,
                                                                                            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) => 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,
                                                                                                          overlays1?: string[] | undefined,
                                                                                                          overlays2?: 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 (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>