bump-cli 2.8.4 → 2.9.0-0

package/dist/commands/diff.js

@@ -0,0 +1,110 @@
+import { ux } from '@oclif/core';
+import { CLIError } from '@oclif/core/errors';
+import { fileArg, otherFileArg } from '../args.js';
+import { BaseCommand } from '../base-command.js';
+import { Diff as CoreDiff } from '../core/diff.js';
+import * as flagsBuilder from '../flags.js';
+export default class Diff extends BaseCommand {
+    static args = {
+        file: fileArg,
+        otherFile: otherFileArg,
+    };
+    static description = 'Get a comparison diff with your documentation from the given file or URL.';
+    static examples = [
+        `Compare a potential new version with the currently published one:
+
+  $ bump diff FILE --doc <your_doc_id_or_slug> --token <your_doc_token>
+  * Comparing the given definition file with the currently deployed one... done
+  Removed: GET /compare
+  Added: GET /versions/{versionId}
+`,
+        `Store the diff in a dedicated file:
+
+  $ bump diff FILE --doc <doc_slug> --token <doc_token> > /tmp/my-saved-diff
+  * Comparing the given definition file with the currently deployed one... done
+
+  $ cat /tmp/my-saved-diff
+  Removed: GET /compare
+  Added: GET /versions/{versionId}
+`,
+        `In case of a non modified definition FILE compared to your existing documentation, no changes are output:
+
+  $ bump diff FILE --doc <doc_slug> --token <your_doc_token>
+  * Comparing the given definition file with the currently deployed one... done
+   ›   Warning: Your documentation has not changed
+`,
+        `Compare two different input files or URL independently to the one published on bump.sh
+
+  $ bump diff FILE FILE2 --doc <doc_slug> --token <your_doc_token>
+  * Comparing the two given definition files... done
+  Updated: POST /versions
+    Body attribute added: previous_version_id
+`,
+    ];
+    static flags = {
+        branch: flagsBuilder.branch(),
+        doc: flagsBuilder.doc(),
+        expires: flagsBuilder.expires(),
+        'fail-on-breaking': flagsBuilder.failOnBreaking(),
+        format: flagsBuilder.format(),
+        hub: flagsBuilder.hub(),
+        token: flagsBuilder.token({ required: false }),
+    };
+    async displayCompareResult(result, format, failOnBreaking) {
+        if (format === 'text' && result.text) {
+            ux.stdout(result.text);
+        }
+        else if (format === 'markdown' && result.markdown) {
+            ux.stdout(result.markdown);
+        }
+        else if (format === 'json' && result.details) {
+            ux.stdout(JSON.stringify(result.details, null, 2));
+        }
+        else if (format === 'html' && result.html) {
+            ux.stdout(result.html);
+        }
+        else {
+            ux.stdout('No structural changes detected.');
+        }
+        if (failOnBreaking && result.breaking) {
+            this.exit(1);
+        }
+    }
+    /*
+      Oclif doesn't type parsed args & flags correctly and especially
+      required-ness which is not known by the compiler, thus the use of
+      the non-null assertion '!' in this command.
+      See https://github.com/oclif/oclif/issues/301 for details
+    */
+    async run() {
+        const { args, flags } = await this.parse(Diff);
+        const [documentation, hub, branch, token, format, expires] = [
+            flags.doc,
+            flags.hub,
+            flags.branch,
+            flags.token,
+            flags.format,
+            flags.expires,
+        ];
+        if (format === 'text') {
+            if (args.otherFile) {
+                ux.action.start('* Comparing the two given definition files');
+            }
+            else {
+                ux.action.start('* Comparing the given definition file with the currently deployed one');
+            }
+        }
+        if (!args.otherFile && (!documentation || !token)) {
+            throw new CLIError('Please provide a second file argument or login with an existing token');
+        }
+        ux.action.status = '...diff on Bump.sh in progress';
+        const diff = await new CoreDiff(this.bump).run(args.file, args.otherFile, documentation, hub, branch, token, format, expires);
+        ux.action.stop();
+        if (diff) {
+            await this.displayCompareResult(diff, format, flags['fail-on-breaking']);
+        }
+        else {
+            ux.stdout('No changes detected.');
+        }
+    }
+}

package/dist/commands/overlay.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../base-command.js';
+export default class Overlay extends BaseCommand<typeof Overlay> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        overlay: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        out: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/overlay.js

@@ -0,0 +1,53 @@
+import { ux } from '@oclif/core';
+import chalk from 'chalk';
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { fileArg, overlayFileArg } from '../args.js';
+import { BaseCommand } from '../base-command.js';
+import { confirm as promptConfirm } from '../core/utils/prompts.js';
+import { API } from '../definition.js';
+import * as flagsBuilder from '../flags.js';
+export default class Overlay extends BaseCommand {
+    static args = {
+        file: fileArg,
+        overlay: overlayFileArg,
+    };
+    static description = 'Apply an OpenAPI specified overlay to your API definition.';
+    static examples = [
+        `Apply the OVERLAY_FILE to the existing DEFINITION_FILE. The resulting
+definition is output on stdout meaning you can redirect it to a new
+file.
+
+${chalk.dim('$ bump overlay DEFINITION_FILE OVERLAY_FILE > destination/file.json')}
+* Let's apply the overlay to the main definition... done
+`,
+    ];
+    static flags = {
+        out: flagsBuilder.out(),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Overlay);
+        const outputPath = flags.out;
+        ux.action.start("* Let's apply the overlay to the main definition");
+        ux.action.status = '...loading definition file';
+        const api = await API.load(args.file);
+        ux.action.status = '...applying overlay';
+        await api.applyOverlay(args.overlay);
+        const [overlayedDefinition] = api.extractDefinition(outputPath);
+        ux.action.stop();
+        if (outputPath) {
+            await mkdir(dirname(outputPath), { recursive: true });
+            let confirm = true;
+            if (existsSync(outputPath)) {
+                confirm = await promptConfirm(`Do you want to override the existing destination file? (${outputPath})`);
+            }
+            if (confirm) {
+                await writeFile(outputPath, overlayedDefinition);
+            }
+        }
+        else {
+            ux.stdout(overlayedDefinition);
+        }
+    }
+}

package/dist/commands/preview.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../base-command.js';
+export default class Preview extends BaseCommand<typeof Preview> {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        live: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        open: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private preview;
+    private waitForChanges;
+}

package/dist/commands/preview.js

@@ -0,0 +1,83 @@
+import { ux } from '@oclif/core';
+import { Mutex } from 'async-mutex';
+import { watch } from 'node:fs';
+import { default as openBrowser } from 'open';
+import { fileArg } from '../args.js';
+import { BaseCommand } from '../base-command.js';
+import { API } from '../definition.js';
+import * as flagsBuilder from '../flags.js';
+export default class Preview extends BaseCommand {
+    static args = {
+        file: fileArg,
+    };
+    static description = 'Create a documentation preview from the given file or URL.';
+    static examples = [
+        `$ <%= config.bin %> <%= command.id %> FILE
+* Your preview is visible at: https://bump.sh/preview/45807371-9a32-48a7-b6e4-1cb7088b5b9b
+`,
+    ];
+    static flags = {
+        live: flagsBuilder.live({
+            description: 'Generate a preview each time you save the given file',
+        }),
+        open: flagsBuilder.open({
+            description: 'Open the generated preview URL in your browser',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Preview);
+        ux.action.start("* Let's render a preview on Bump.sh");
+        const currentPreview = await this.preview(args.file, flags.open);
+        if (flags.live) {
+            await this.waitForChanges(args.file, currentPreview);
+        }
+        else {
+            ux.action.stop();
+        }
+    }
+    async preview(file, open = false, currentPreview = undefined) {
+        const api = await API.load(file);
+        const [definition, references] = api.extractDefinition();
+        this.d(`${file} looks like an ${api.specName} spec version ${api.version}`);
+        const request = {
+            definition,
+            references,
+        };
+        ux.action.status = '...in progress';
+        const response = currentPreview
+            ? await this.bump.putPreview(currentPreview.id, request)
+            : await this.bump.postPreview(request);
+        if (!currentPreview) {
+            ux.action.status = '...done';
+            ux.stdout(ux.colorize('green', `Your preview is visible at: ${response.data.public_url} (Expires at ${response.data.expires_at})`));
+        }
+        if (open && response.data.public_url) {
+            await openBrowser(response.data.public_url);
+        }
+        return response.data;
+    }
+    async waitForChanges(file, preview) {
+        const mutex = new Mutex();
+        let currentPreview = preview;
+        ux.action.status = `Waiting for changes on file ${file}...`;
+        watch(file, async () => {
+            if (!mutex.isLocked()) {
+                const release = await mutex.acquire();
+                this.preview(file, false, currentPreview)
+                    .then((preview) => {
+                    currentPreview = preview;
+                    ux.stdout(ux.colorize('green', ` ↳ has been updated (Expires at ${preview.expires_at})`));
+                    ux.action.status = `Waiting for changes on file ${file}`;
+                })
+                    .catch((error) => {
+                    this.warn(error);
+                })
+                    .finally(() => {
+                    setTimeout(() => {
+                        release();
+                    }, 1000); // Prevent previewing faster than once per second
+                });
+            }
+        });
+    }
+}

package/{lib/core/definition_directory.d.ts → dist/core/definition-directory.d.ts}

@@ -1,20 +1,22 @@
-import { API } from '../definition';
-export declare type DefinitionConfig = {
+import { API } from '../definition.js';
+export type DefinitionConfig = {
     definition: API;
     file: string;
     slug: string;
 };
 export declare class DefinitionDirectory {
-    protected readonly path: string;
+    protected buildNewFilename: (slug: string) => string;
     protected readonly definitions: DefinitionConfig[];
     protected readonly filenamePattern: RegExp;
     protected readonly humanFilenamePattern: string;
-    protected buildNewFilename: (slug: string) => string;
+    protected readonly path: string;
     constructor(directory: string, filenamePattern: string);
-    readDefinitions(): Promise<DefinitionConfig[]>;
+    d(formatter: any, ...args: any[]): void;
     definitionsExists(): boolean;
-    sequentialMap(callback: (definition: DefinitionConfig) => Promise<DefinitionConfig>): Promise<void>;
-    renameToConvention(documentation: DefinitionConfig): Promise<void>;
     interactiveSelection(): Promise<DefinitionConfig[]>;
-    d(formatter: any, ...args: any[]): void;
+    map(callback: (definition: DefinitionConfig) => Promise<DefinitionConfig>): Promise<DefinitionConfig[]>;
+    readDefinitions(): Promise<DefinitionConfig[]>;
+    renameToConvention(documentation: DefinitionConfig): Promise<void>;
+    sequentialMap(callback: (definition: DefinitionConfig) => Promise<void>): Promise<DefinitionConfig[]>;
+    stdoutDefinitions(): void;
 }

package/dist/core/definition-directory.js

@@ -0,0 +1,149 @@
+import * as p from '@clack/prompts';
+import { ux } from '@oclif/core';
+import { CLIError, ExitError } from '@oclif/core/errors';
+import chalk from 'chalk';
+import debug from 'debug';
+import { rename } from 'node:fs';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { confirm as promptConfirm } from '../core/utils/prompts.js';
+import { API } from '../definition.js';
+import { File } from './utils/file.js';
+export class DefinitionDirectory {
+    buildNewFilename;
+    definitions;
+    filenamePattern;
+    humanFilenamePattern;
+    path;
+    constructor(directory, filenamePattern) {
+        this.path = resolve(directory);
+        this.definitions = [];
+        // // Transform basic patterns '*' or '{text}' into a real RegExp
+        this.filenamePattern = new RegExp('^' + filenamePattern.replace('*', '.*?').replace(/{.*?}/, '(?<slug>.+?)') + '$');
+        this.buildNewFilename = (slug) => filenamePattern.replace('*', '').replace(/{.*?}/, slug);
+        this.humanFilenamePattern = filenamePattern.replace(/{(.*?)}/, `${chalk.inverse('{$1}')}`);
+    }
+    // Function signature type taken from @types/debug
+    // Debugger(formatter: any, ...args: any[]): void;
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    d(formatter, ...args) {
+        return debug(`bump-cli:core:interactive`)(formatter, ...args);
+    }
+    definitionsExists() {
+        return this.definitions.length > 0;
+    }
+    async interactiveSelection() {
+        p.intro(`This interactive form will help you rename your API contrat files to follow the expected naming convention.\n${chalk.gray('│  ')}Once finished, the selected files will be deployed to Bump.sh.\n${chalk.gray('│  ')}\n${chalk.gray('│  ')}File naming convention: ${this.humanFilenamePattern}${chalk.dim('.[json|yml|yaml]')}\n`);
+        let fileOptions = File.listInvalidConventionFiles(this.path, this.filenamePattern);
+        if (fileOptions.length === 0) {
+            throw new CLIError(`No JSON or YAML files needing a rename were found in ${this.path}.\nAre you sure you need the ${chalk.dim('--interactive')} flag?`);
+        }
+        let shouldContinue = true;
+        while (shouldContinue) {
+            fileOptions = fileOptions.filter(({ label }) => {
+                // keep file only if it's NOT already present in the directory
+                return (this.definitions.findIndex(({ file }) => {
+                    return basename(file) === label;
+                }) === -1);
+            });
+            const filePrompt = {
+                fileName: () => p.select({
+                    message: `Which file do you want to deploy from ${chalk.dim(this.path)}?`,
+                    options: fileOptions,
+                }),
+            };
+            const groupPrompt = {
+                /* Results type should be taken from the previous prompts
+                 * defined with clack/prompt  */
+                slug: ({ results }) => p.text({
+                    message: `What is the ${chalk.inverse('documentation slug')} for this ${chalk.dim(results.fileName)} file?`,
+                }),
+            };
+            // eslint-disable-next-line no-await-in-loop
+            const prompt = await p.group({
+                ...filePrompt,
+                ...groupPrompt,
+                shouldContinue: () => p.confirm({ message: 'Do you want to select another file?' }),
+            }, {
+                onCancel() {
+                    p.cancel('Deploy cancelled.');
+                    throw new ExitError(1);
+                },
+            });
+            const file = join(this.path, prompt.fileName);
+            // eslint-disable-next-line no-await-in-loop
+            const definition = await API.load(file);
+            this.d(`${file} looks like an ${definition.specName} spec version ${definition.version}`);
+            this.definitions.push({
+                definition,
+                file,
+                slug: prompt.slug,
+            });
+            shouldContinue = prompt.shouldContinue;
+        }
+        p.outro(`You're all set. Your deployments will start soon.`);
+        return this.definitions;
+    }
+    async map(callback) {
+        return Promise.all(this.definitions.map((definition) => callback(definition)));
+    }
+    async readDefinitions() {
+        for await (const { filename, value } of File.listValidConventionFiles(this.path, this.filenamePattern)) {
+            const file = join(this.path, value);
+            /* We already check the filenamePattern match inside the
+            `File.listValidConventionFiles` method so we are sure the group
+            matched exists. */
+            const slug = filename.match(this.filenamePattern).groups.slug;
+            const definition = await API.load(file);
+            this.definitions.push({
+                definition,
+                file,
+                slug,
+            });
+        }
+        return this.definitions;
+    }
+    async renameToConvention(documentation) {
+        const { file, slug } = documentation;
+        if (this.filenamePattern.test(basename(file, extname(file))))
+            return;
+        // Default convention is defined in the flags.ts file for the
+        // 'filenamePattern' flag.
+        const newFilename = this.buildNewFilename(slug);
+        const newFile = `${dirname(file)}/${newFilename}${extname(file)}`;
+        const confirm = await promptConfirm(`Do you want to rename ${file} to ${newFile} (for later deployments)?`);
+        if (confirm) {
+            await rename(file, newFile, (err) => {
+                if (err)
+                    throw err;
+                ux.stdout(ux.colorize('green', `Renamed ${file} to ${newFile}.`));
+            });
+        }
+    }
+    async sequentialMap(callback) {
+        for (const definition of this.definitions) {
+            // We explicitly need a sequential run of promises, so the await
+            // in loop is needed.
+            /* eslint-disable-next-line no-await-in-loop */
+            await callback(definition);
+        }
+        return this.definitions;
+    }
+    stdoutDefinitions() {
+        if (this.definitions.length > 0) {
+            ux.stdout(chalk.underline(`We've found ${this.definitions.length} valid API definitions to deploy`));
+            ux.stdout(`└─ ${this.path}`);
+            let iterations = this.definitions.length;
+            for (const { definition, file } of this.definitions) {
+                const filename = `${basename(file)} (${definition.specName} spec version ${definition.version})`;
+                iterations -= 1;
+                if (iterations) {
+                    ux.stdout(`   ├─ ${filename}`);
+                }
+                else {
+                    ux.stdout(`   └─ ${filename}`);
+                }
+            }
+            ux.stdout('');
+        }
+    }
+}

package/{lib → dist}/core/deploy.d.ts

@@ -1,14 +1,11 @@
-import * as Config from '@oclif/config';
-import { API } from '../definition';
-import { BumpApi } from '../api';
-import { VersionRequest, VersionResponse } from '../api/models';
+import { BumpApi } from '../api/index.js';
+import { VersionRequest, VersionResponse } from '../api/models.js';
+import { API } from '../definition.js';
 export declare class Deploy {
-    _bump: BumpApi;
-    _config: Config.IConfig;
-    constructor(config: Config.IConfig);
+    private _bump;
+    constructor(bumpClient: BumpApi);
+    protected createVersion(request: VersionRequest, token: string): Promise<VersionResponse | undefined>;
+    d(formatter: any, ...args: any[]): void;
     run(api: API, dryRun: boolean, documentation: string, token: string, hub: string | undefined, autoCreate: boolean, documentationName: string | undefined, branch: string | undefined, overlay?: string | undefined): Promise<VersionResponse | undefined>;
-    get bumpClient(): BumpApi;
-    createVersion(request: VersionRequest, token: string): Promise<VersionResponse | undefined>;
     validateVersion(version: VersionRequest, token: string): Promise<undefined>;
-    d(formatter: any, ...args: any[]): void;
 }

package/{lib → dist}/core/deploy.js

@@ -1,27 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deploy = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
-const api_1 = require("../api");
-class Deploy {
-    constructor(config) {
-        this._config = config;
+import debug from 'debug';
+export class Deploy {
+    _bump;
+    constructor(bumpClient) {
+        this._bump = bumpClient;
+    }
+    async createVersion(request, token) {
+        const response = await this._bump.postVersion(request, token);
+        let version;
+        switch (response.status) {
+            case 204: {
+                break;
+            }
+            case 201: {
+                version = response.data ?? { doc_public_url: 'https://bump.sh', id: '' };
+                break;
+            }
+            default: {
+                this.d(`API status response was ${response.status}. Expected 201 or 204.`);
+                throw new Error('Unexpected server response. Please contact support at https://bump.sh if this error persists');
+            }
+        }
+        return version;
+    }
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    d(formatter, ...args) {
+        return debug(`bump-cli:core:deploy`)(formatter, ...args);
     }
     async run(api, dryRun, documentation, token, hub, autoCreate, documentationName, branch, overlay) {
-        let version = undefined;
+        let version;
         if (overlay) {
             await api.applyOverlay(overlay);
         }
         const [definition, references] = api.extractDefinition();
         const request = {
-            documentation,
-            hub,
-            documentation_name: documentationName,
             auto_create_documentation: autoCreate && !dryRun,
+            branch_name: branch,
             definition,
+            documentation,
+            documentation_name: documentationName,
+            hub,
             references,
-            branch_name: branch,
         };
         if (dryRun) {
             await this.validateVersion(request, token);
@@ -31,44 +49,18 @@ class Deploy {
         }
         return version;
     }
-    get bumpClient() {
-        if (!this._bump)
-            this._bump = new api_1.BumpApi(this._config);
-        return this._bump;
-    }
-    async createVersion(request, token) {
-        const response = await this.bumpClient.postVersion(request, token);
-        let version = undefined;
-        switch (response.status) {
-            case 204:
-                break;
-            case 201:
-                version = response.data
-                    ? response.data
-                    : { id: '', doc_public_url: 'https://bump.sh' };
-                break;
-            default:
-                this.d(`API status response was ${response.status}. Expected 201 or 204.`);
-                throw new Error('Unexpected server response. Please contact support at https://bump.sh if this error persists');
-        }
-        return version;
-    }
+    // Function signature type taken from @types/debug
+    // Debugger(formatter: any, ...args: any[]): void;
     async validateVersion(version, token) {
-        const response = await this.bumpClient.postValidation(version, token);
+        const response = await this._bump.postValidation(version, token);
         switch (response.status) {
-            case 200:
+            case 200: {
                 break;
-            default:
+            }
+            default: {
                 this.d(`API status response was ${response.status}. Expected 200.`);
                 throw new Error('Unexpected server response. Please contact support at https://bump.sh if this error persists');
+            }
         }
-        return;
-    }
-    // Function signature type taken from @types/debug
-    // Debugger(formatter: any, ...args: any[]): void;
-    /* eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any */
-    d(formatter, ...args) {
-        return (0, debug_1.default)(`bump-cli:core:deploy`)(formatter, ...args);
     }
 }
-exports.Deploy = Deploy;

package/{lib → dist}/core/diff.d.ts

@@ -1,24 +1,21 @@
-import * as Config from '@oclif/config';
-import { BumpApi } from '../api';
-import { VersionResponse, WithDiff, DiffResponse } from '../api/models';
+import { BumpApi } from '../api/index.js';
+import { DiffResponse, VersionResponse, WithDiff } from '../api/models.js';
 export declare class Diff {
     static readonly TIMEOUT = 120;
-    _bump: BumpApi;
-    _config: Config.IConfig;
-    constructor(config: Config.IConfig);
-    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>;
-    get bumpClient(): BumpApi;
+    private _bump;
+    constructor(bumpClient: BumpApi);
     get pollingPeriod(): number;
     createDiff(file1: string, file2: string, expires: string | undefined): Promise<DiffResponse | undefined>;
     createVersion(file: string, documentation: string, token: string, hub: string | undefined, branch_name: string | undefined, previous_version_id?: string | undefined): Promise<VersionResponse | undefined>;
-    waitResult(result: VersionResponse | DiffResponse, token: string | undefined, opts: {
-        timeout: number;
+    d(formatter: any, ...args: any[]): void;
+    extractDiff(versionWithDiff: VersionResponse & WithDiff): DiffResponse;
+    isVersion(result: DiffResponse | VersionResponse): result is VersionResponse;
+    isVersionWithDiff(result: DiffResponse | (VersionResponse & WithDiff)): result is VersionResponse & WithDiff;
+    pollingDelay(): Promise<void>;
+    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>;
+    waitResult(result: DiffResponse | VersionResponse, token: string | undefined, opts: {
         format: string;
+        timeout: number;
     }): Promise<DiffResponse>;
-    pollingDelay(): Promise<void>;
     private delay;
-    d(formatter: any, ...args: any[]): void;
-    isVersion(result: VersionResponse | DiffResponse): result is VersionResponse;
-    isVersionWithDiff(result: (VersionResponse & WithDiff) | DiffResponse): result is VersionResponse & WithDiff;
-    extractDiff(versionWithDiff: VersionResponse & WithDiff): DiffResponse;
 }