bump-cli 2.8.4 → 2.9.1

package/lib/core/definition_directory.js

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefinitionDirectory = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
-const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
-const fs_1 = require("fs");
-const node_path_1 = require("node:path");
-const p = (0, tslib_1.__importStar)(require("@clack/prompts"));
-const errors_1 = require("@oclif/errors");
-const cli_1 = require("../cli");
-const definition_1 = require("../definition");
-const file_1 = require("./utils/file");
-const prompts_1 = require("../core/utils/prompts");
-class DefinitionDirectory {
-    constructor(directory, filenamePattern) {
-        this.path = (0, node_path_1.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_1.default.inverse('{$1}')}`);
-    }
-    async readDefinitions() {
-        var e_1, _a;
-        try {
-            for (var _b = (0, tslib_1.__asyncValues)(file_1.File.listValidConventionFiles(this.path, this.filenamePattern)), _c; _c = await _b.next(), !_c.done;) {
-                const { value, filename } = _c.value;
-                const file = (0, node_path_1.join)(this.path, value);
-                /* We already check the filenamePattern match inside the
-                `File.listValidConventionFiles` method so we are sure the group
-                matched exists. */
-                /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
-                const slug = filename.match(this.filenamePattern).groups.slug;
-                const definition = await definition_1.API.load(file);
-                this.definitions.push({
-                    file,
-                    definition,
-                    slug,
-                });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        if (this.definitions.length) {
-            cli_1.cli.info(chalk_1.default.underline(`We've found ${this.definitions.length} valid API definitions to deploy`));
-            const subtree = cli_1.cli.tree();
-            this.definitions.forEach(({ file, definition }) => subtree.insert(`${(0, node_path_1.basename)(file)} (${definition.specName} spec version ${definition.version})`));
-            const tree = cli_1.cli.tree();
-            tree.insert(this.path, subtree);
-            tree.display();
-            cli_1.cli.info('');
-        }
-        return this.definitions;
-    }
-    definitionsExists() {
-        return !!this.definitions.length;
-    }
-    async sequentialMap(callback) {
-        for (const definition of this.definitions) {
-            await callback(definition);
-        }
-        return;
-    }
-    async renameToConvention(documentation) {
-        const { file, slug } = documentation;
-        if ((0, node_path_1.basename)(file, (0, node_path_1.extname)(file)).match(this.filenamePattern))
-            return;
-        // Default convention is defined in the flags.ts file for the
-        // 'filenamePattern' flag.
-        const newFilename = this.buildNewFilename(slug);
-        const newFile = `${(0, node_path_1.dirname)(file)}/${newFilename}${(0, node_path_1.extname)(file)}`;
-        let confirm = true;
-        await (0, prompts_1.confirm)(`Do you want to rename ${file} to ${newFile} (for later deployments)?`).catch(() => {
-            confirm = false;
-        });
-        if (confirm) {
-            await (0, fs_1.rename)(file, newFile, (err) => {
-                if (err)
-                    throw err;
-                cli_1.cli.styledSuccess(`Renamed ${file} to ${newFile}.`);
-            });
-        }
-        return;
-    }
-    async interactiveSelection() {
-        p.intro(`This interactive form will help you rename your API contrat files to follow the expected naming convention.\n${chalk_1.default.gray('│  ')}Once finished, the selected files will be deployed to Bump.sh.\n${chalk_1.default.gray('│  ')}\n${chalk_1.default.gray('│  ')}File naming convention: ${this.humanFilenamePattern}${chalk_1.default.dim('.[json|yml|yaml]')}\n`);
-        const fileOptions = file_1.File.listInvalidConventionFiles(this.path, this.filenamePattern);
-        if (!fileOptions.length) {
-            throw new errors_1.CLIError(`No JSON or YAML files needing a rename were found in ${this.path}.\nAre you sure you need the ${chalk_1.default.dim('--interactive')} flag?`);
-        }
-        let shouldContinue = true;
-        while (shouldContinue) {
-            const filePrompt = {
-                fileName: () => p.select({
-                    message: `Which file do you want to deploy from ${chalk_1.default.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_1.default.inverse('documentation slug')} for this ${chalk_1.default.dim(results.fileName)} file?`,
-                }),
-            };
-            const prompt = await p.group(Object.assign(Object.assign(Object.assign({}, filePrompt), groupPrompt), { shouldContinue: () => p.confirm({ message: 'Do you want to select another file?' }) }), {
-                onCancel: () => {
-                    p.cancel('Deploy cancelled.');
-                    process.exit(0);
-                },
-            });
-            const file = (0, node_path_1.join)(this.path, prompt.fileName);
-            const definition = await definition_1.API.load(file);
-            this.d(`${file} looks like an ${definition.specName} spec version ${definition.version}`);
-            this.definitions.push({
-                file,
-                definition,
-                slug: prompt.slug,
-            });
-            shouldContinue = prompt.shouldContinue;
-        }
-        p.outro(`You're all set. Your deployments will start soon.`);
-        return this.definitions;
-    }
-    // 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:interactive`)(formatter, ...args);
-    }
-}
-exports.DefinitionDirectory = DefinitionDirectory;

package/lib/core/utils/file.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.File = exports.isDir = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const isDir = (path) => {
-    try {
-        return (0, fs_1.statSync)(path).isDirectory();
-    }
-    catch (e) {
-        return false;
-    }
-};
-exports.isDir = isDir;
-class File {
-    static listValidConventionFiles(path, regex) {
-        return File.listValidFormatFiles(path).filter(({ filename }) => {
-            return filename.match(regex);
-        });
-    }
-    static listInvalidConventionFiles(path, regex) {
-        return File.listValidFormatFiles(path).filter(({ filename }) => {
-            return !filename.match(regex);
-        });
-    }
-    static listValidFormatFiles(path) {
-        return (0, fs_1.readdirSync)(path)
-            .filter((file) => {
-            return File.supportedFormats.includes((0, path_1.extname)(file));
-        })
-            .map((file) => {
-            return {
-                value: file,
-                label: (0, path_1.basename)(file),
-                filename: (0, path_1.basename)(file, (0, path_1.extname)(file)),
-            };
-        });
-    }
-}
-exports.File = File;
-File.supportedFormats = ['.yml', '.yaml', '.json'];

package/lib/core/utils/prompts.d.ts

@@ -1 +0,0 @@
-export declare const confirm: (message?: string) => Promise<void>;

package/lib/core/utils/prompts.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirm = void 0;
-const tslib_1 = require("tslib");
-const errors_1 = require("@oclif/errors");
-const p = (0, tslib_1.__importStar)(require("@clack/prompts"));
-const confirm = async (message = 'Continue?') => {
-    const prompt = await p.group({
-        shouldContinue: () => p.confirm({ message: message }),
-    }, {
-        onCancel: () => {
-            p.cancel('Cancelled.');
-            process.exit(0);
-        },
-    });
-    if (!prompt.shouldContinue) {
-        throw new errors_1.CLIError(`Cancelled`);
-    }
-    return;
-};
-exports.confirm = confirm;

package/lib/definition.js

@@ -1,218 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SupportedFormat = exports.API = void 0;
-const tslib_1 = require("tslib");
-const errors_1 = require("@oclif/errors");
-const json_schema_ref_parser_1 = (0, tslib_1.__importDefault)(require("@apidevtools/json-schema-ref-parser"));
-const options_1 = require("@apidevtools/json-schema-ref-parser/lib/options");
-const specs_1 = (0, tslib_1.__importDefault)(require("@asyncapi/specs"));
-const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const yaml_1 = require("@stoplight/yaml");
-const overlay_1 = require("./core/overlay");
-class SupportedFormat {
-}
-exports.SupportedFormat = SupportedFormat;
-SupportedFormat.openapi = {
-    '2.0': require('oas-schemas/schemas/v2.0/schema.json'),
-    '3.0': require('oas-schemas/schemas/v3.0/schema.json'),
-    '3.1': require('oas-schemas/schemas/v3.1/schema.json'),
-};
-SupportedFormat.asyncapi = {
-    '2.0': specs_1.default.schemas['2.0.0'],
-    '2.1': specs_1.default.schemas['2.1.0'],
-    '2.2': specs_1.default.schemas['2.2.0'],
-    '2.3': specs_1.default.schemas['2.3.0'],
-    '2.4': specs_1.default.schemas['2.4.0'],
-    '2.5': specs_1.default.schemas['2.5.0'],
-    '2.6': specs_1.default.schemas['2.6.0'],
-};
-class UnsupportedFormat extends errors_1.CLIError {
-    constructor(message = '') {
-        const compatOpenAPI = Object.keys(SupportedFormat.openapi).join(', ');
-        const compatAsyncAPI = Object.keys(SupportedFormat.asyncapi).join(', ');
-        const errorMsgs = [
-            `Unsupported API specification (${message})`,
-            `Please try again with an OpenAPI ${compatOpenAPI} or AsyncAPI ${compatAsyncAPI} file.`,
-        ];
-        super(errorMsgs.join('\n'));
-    }
-}
-class API {
-    constructor(location, $refs) {
-        this.location = location;
-        this.references = [];
-        const [raw, parsed] = this.resolveContent($refs);
-        this.rawDefinition = raw;
-        this.definition = parsed;
-        this.specName = this.getSpecName(parsed);
-        this.version = this.getVersion(parsed);
-        this.spec = this.getSpec(parsed);
-        if (this.spec === undefined) {
-            throw new UnsupportedFormat(`${this.specName} ${this.version}`);
-        }
-    }
-    getSpec(definition) {
-        if (API.isAsyncAPI(definition)) {
-            return SupportedFormat.asyncapi[this.versionWithoutPatch()];
-        }
-        else if (API.isOpenAPIOverlay(definition)) {
-            return { overlay: { type: 'string' } };
-        }
-        else {
-            return SupportedFormat.openapi[this.versionWithoutPatch()];
-        }
-    }
-    getSpecName(definition) {
-        if (API.isAsyncAPI(definition)) {
-            return 'AsyncAPI';
-        }
-        else {
-            return 'OpenAPI';
-        }
-    }
-    getVersion(definition) {
-        if (API.isAsyncAPI(definition)) {
-            return definition.asyncapi;
-        }
-        else {
-            return (definition.openapi || definition.swagger);
-        }
-    }
-    guessFormat(output) {
-        return (output || this.location).endsWith('.json') ? 'json' : 'yaml';
-    }
-    versionWithoutPatch() {
-        const [major, minor] = this.version.split('.', 3);
-        return `${major}.${minor}`;
-    }
-    /* Resolve reference absolute paths to the main api location when possible */
-    resolveRelativeLocation(absPath) {
-        const url = (location) => {
-            try {
-                return new URL(location);
-            }
-            catch (_a) {
-                return { hostname: '' };
-            }
-        };
-        const definitionUrl = url(this.location);
-        const refUrl = url(absPath);
-        if (absPath.match(/^\//) || // Unix style filesystem path
-            absPath.match(/^[a-zA-Z]+\:\\/) || // Windows style filesystem path
-            (absPath.match(/^https?:\/\//) && definitionUrl.hostname === refUrl.hostname) // Same domain URLs
-        ) {
-            return path_1.default.relative(path_1.default.dirname(this.location), absPath);
-        }
-        else {
-            return absPath;
-        }
-    }
-    resolveContent($refs) {
-        const values = $refs.values();
-        let mainReference = { parsed: {}, raw: '' };
-        for (const [absPath, reference] of Object.entries(values)) {
-            if (absPath === this.location || absPath === path_1.default.resolve(this.location)) {
-                // $refs.values is not properly typed so we need to force it
-                // with the resulting type of our custom defined parser
-                mainReference = reference;
-            }
-            else {
-                // $refs.values is not properly typed so we need to force it
-                // with the resulting type of our custom defined parser
-                const { raw } = reference;
-                if (!raw) {
-                    throw new UnsupportedFormat('Reference ${absPath} is empty');
-                }
-                this.references.push({
-                    location: this.resolveRelativeLocation(absPath),
-                    content: raw,
-                });
-            }
-        }
-        const { raw, parsed } = mainReference;
-        if (!parsed || !(parsed instanceof Object) || !('info' in parsed)) {
-            throw new UnsupportedFormat("Definition needs to be an object with at least an 'info' key");
-        }
-        if (!API.isOpenAPI(parsed) &&
-            !API.isAsyncAPI(parsed) &&
-            !API.isOpenAPIOverlay(parsed)) {
-            throw new UnsupportedFormat();
-        }
-        return [raw, parsed];
-    }
-    serializeDefinition(outputPath) {
-        if (this.overlayedDefinition) {
-            let serializedDefinition;
-            if (this.guessFormat(outputPath) == 'json') {
-                serializedDefinition = JSON.stringify(this.overlayedDefinition);
-            }
-            else {
-                serializedDefinition = (0, yaml_1.safeStringify)(this.overlayedDefinition);
-            }
-            return serializedDefinition;
-        }
-        else {
-            return this.rawDefinition;
-        }
-    }
-    static isOpenAPI(definition) {
-        return (typeof definition.openapi === 'string' || typeof definition.swagger === 'string');
-    }
-    static isAsyncAPI(definition) {
-        return 'asyncapi' in definition;
-    }
-    static isOpenAPIOverlay(definition) {
-        return 'overlay' in definition;
-    }
-    extractDefinition(outputPath) {
-        const references = [];
-        for (let i = 0; i < this.references.length; i++) {
-            const reference = this.references[i];
-            references.push({
-                location: reference.location,
-                content: reference.content,
-            });
-        }
-        return [this.serializeDefinition(outputPath), references];
-    }
-    async applyOverlay(overlayPath) {
-        const overlay = await API.load(overlayPath);
-        const overlayDefinition = overlay.definition;
-        if (!API.isOpenAPIOverlay(overlayDefinition)) {
-            throw new Error(`${overlayPath} does not look like an OpenAPI overlay`);
-        }
-        this.overlayedDefinition = await new overlay_1.Overlay().run(this.definition, overlayDefinition);
-    }
-    static async load(path) {
-        const JSONParser = options_1.defaults.parse.json;
-        const YAMLParser = options_1.defaults.parse.yaml;
-        const TextParser = options_1.defaults.parse.text;
-        // We override the default parsers from $RefParser to be able
-        // to keep the raw content of the files parsed
-        const withRawTextParser = (parser) => {
-            return Object.assign(Object.assign({}, parser), { parse: async (file) => {
-                    const parsed = (await parser.parse(file));
-                    return { parsed, raw: TextParser.parse(file) };
-                } });
-        };
-        return json_schema_ref_parser_1.default
-            .resolve(path, {
-            parse: {
-                json: withRawTextParser(JSONParser),
-                yaml: withRawTextParser(YAMLParser),
-                text: Object.assign(Object.assign({}, TextParser), { parse: async (file) => {
-                        const parsed = await TextParser.parse(file);
-                        return { parsed, raw: parsed };
-                    }, canParse: ['.md', '.markdown'], encoding: 'utf8' }),
-            },
-            dereference: { circular: false },
-        })
-            .then(($refs) => {
-            return new API(path, $refs);
-        })
-            .catch((err) => {
-            throw new errors_1.CLIError(err);
-        });
-    }
-}
-exports.API = API;

package/lib/flags.d.ts

@@ -1,20 +0,0 @@
-import { flags } from '@oclif/command';
-import * as Parser from '@oclif/parser';
-export * from '@oclif/command/lib/flags';
-declare const doc: flags.Definition<string>;
-declare const docName: flags.Definition<string>;
-declare const hub: flags.Definition<string>;
-declare const filenamePattern: flags.Definition<string>;
-declare const branch: flags.Definition<string>;
-declare const token: flags.Definition<string>;
-declare const autoCreate: (options?: {}) => Parser.flags.IBooleanFlag<boolean>;
-declare const interactive: (options?: {}) => Parser.flags.IBooleanFlag<boolean>;
-declare const dryRun: (options?: {}) => Parser.flags.IBooleanFlag<boolean>;
-declare const open: (options?: {}) => Parser.flags.IBooleanFlag<boolean>;
-declare const failOnBreaking: (options?: {}) => Parser.flags.IBooleanFlag<boolean>;
-declare const live: (options?: {}) => Parser.flags.IBooleanFlag<boolean>;
-declare const format: flags.Definition<string>;
-declare const expires: flags.Definition<string>;
-declare const out: flags.Definition<string>;
-declare const overlay: flags.Definition<string>;
-export { doc, docName, hub, branch, token, autoCreate, interactive, filenamePattern, dryRun, open, failOnBreaking, live, format, expires, out, overlay, };

package/lib/flags.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overlay = exports.out = exports.expires = exports.format = exports.live = exports.failOnBreaking = exports.open = exports.dryRun = exports.filenamePattern = exports.interactive = exports.autoCreate = exports.token = exports.branch = exports.hub = exports.docName = exports.doc = void 0;
-const tslib_1 = require("tslib");
-const command_1 = require("@oclif/command");
-// Re-export oclif flags https://oclif.io/docs/flags
-(0, tslib_1.__exportStar)(require("@oclif/command/lib/flags"), exports);
-// Custom flags for bump-cli
-const doc = command_1.flags.build({
-    char: 'd',
-    description: 'Documentation public id or slug. Can be provided via BUMP_ID environment variable',
-    default: () => {
-        const envDoc = process.env.BUMP_ID;
-        if (envDoc)
-            return envDoc;
-        // Search doc id in .bump/config.json file?
-    },
-});
-exports.doc = doc;
-const docName = command_1.flags.build({
-    char: 'n',
-    description: 'Documentation name. Used with --auto-create flag.',
-    dependsOn: ['auto-create'],
-});
-exports.docName = docName;
-const hub = command_1.flags.build({
-    char: 'b',
-    description: 'Hub id or slug. Can be provided via BUMP_HUB_ID environment variable',
-    default: () => {
-        const envHub = process.env.BUMP_HUB_ID;
-        if (envHub)
-            return envHub;
-        // Search hub id in .bump/config.json file?
-    },
-});
-exports.hub = hub;
-const filenamePattern = command_1.flags.build({
-    description: `Pattern to extract the documentation slug from filenames when deploying a DIRECTORY. Pattern uses only '*' and '{slug}' as special characters to extract the slug from a filename without extension. Used with --hub flag only.`,
-    default: '{slug}-api',
-});
-exports.filenamePattern = filenamePattern;
-const branch = command_1.flags.build({
-    char: 'B',
-    description: 'Branch name. Can be provided via BUMP_BRANCH_NAME environment variable',
-    default: () => {
-        const envBranch = process.env.BUMP_BRANCH_NAME;
-        if (envBranch)
-            return envBranch;
-    },
-});
-exports.branch = branch;
-const token = command_1.flags.build({
-    char: 't',
-    required: true,
-    description: 'Documentation or Hub token. Can be provided via BUMP_TOKEN environment variable',
-    default: () => {
-        const envToken = process.env.BUMP_TOKEN;
-        if (envToken)
-            return envToken;
-    },
-});
-exports.token = token;
-const autoCreate = (options = {}) => {
-    return command_1.flags.boolean(Object.assign({ description: 'Automatically create the documentation if needed (only available with a --hub flag). Documentation name can be provided with --doc-name flag. Default: false', dependsOn: ['hub'] }, options));
-};
-exports.autoCreate = autoCreate;
-const interactive = (options = {}) => {
-    return command_1.flags.boolean(Object.assign({ description: "Interactively create a configuration file to deploy a Hub (only available with a --hub flag). This will start an interactive process if you don't have a CLI configuration file. Default: false", dependsOn: ['hub'] }, options));
-};
-exports.interactive = interactive;
-const dryRun = (options = {}) => {
-    return command_1.flags.boolean(Object.assign({ description: 'Validate a new documentation version. Does everything a normal deploy would do except publishing the new version. Useful in automated environments such as test platforms or continuous integration. Default: false' }, options));
-};
-exports.dryRun = dryRun;
-const open = (options = {}) => {
-    return command_1.flags.boolean(Object.assign({ char: 'o', default: false }, options));
-};
-exports.open = open;
-const failOnBreaking = (options = {}) => {
-    return command_1.flags.boolean(Object.assign({ char: 'F', description: 'Fail when diff contains a breaking change', default: () => {
-            const envCi = process.env.CI;
-            if (envCi) {
-                return true;
-            }
-            else {
-                return false;
-            }
-        } }, options));
-};
-exports.failOnBreaking = failOnBreaking;
-const live = (options = {}) => {
-    return command_1.flags.boolean(Object.assign({ char: 'l', default: false }, options));
-};
-exports.live = live;
-const format = command_1.flags.build({
-    char: 'f',
-    description: 'Format in which to provide the diff result',
-    default: 'text',
-    options: ['text', 'markdown', 'json', 'html'],
-});
-exports.format = format;
-const expires = command_1.flags.build({
-    char: 'e',
-    description: "Specify a longer expiration date for public diffs (defaults to 1 day). Use iso8601 format to provide a date, or you can use `--expires 'never'` to keep the result live indefinitely.",
-});
-exports.expires = expires;
-const out = command_1.flags.build({
-    char: 'o',
-    description: 'Output file path',
-});
-exports.out = out;
-const overlay = command_1.flags.build({
-    char: 'o',
-    description: 'Path or URL of an overlay file to apply before deploying',
-});
-exports.overlay = overlay;

package/lib/index.d.ts

@@ -1,7 +0,0 @@
-import { run } from '@oclif/command';
-import { Diff } from './core/diff';
-import { Overlay } from './core/overlay';
-import Deploy from './commands/deploy';
-import Preview from './commands/preview';
-export { VersionResponse, PreviewResponse, DiffResponse, WithDiff } from './api/models';
-export { run, Deploy, Diff, Preview, Overlay };

package/lib/index.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Overlay = exports.Preview = exports.Diff = exports.Deploy = exports.run = void 0;
-const tslib_1 = require("tslib");
-const command_1 = require("@oclif/command");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });
-const diff_1 = require("./core/diff");
-Object.defineProperty(exports, "Diff", { enumerable: true, get: function () { return diff_1.Diff; } });
-const overlay_1 = require("./core/overlay");
-Object.defineProperty(exports, "Overlay", { enumerable: true, get: function () { return overlay_1.Overlay; } });
-const deploy_1 = (0, tslib_1.__importDefault)(require("./commands/deploy"));
-exports.Deploy = deploy_1.default;
-const preview_1 = (0, tslib_1.__importDefault)(require("./commands/preview"));
-exports.Preview = preview_1.default;

package/{lib → dist}/api/models.d.ts

@@ -2,67 +2,67 @@ export interface PingResponse {
     pong?: string;
 }
 export interface PreviewResponse {
-    id: string;
     expires_at?: string;
+    id: string;
     public_url?: string;
 }
 export interface InvalidDefinitionError {
-    message?: string;
     errors: {
         [keys: string]: unknown;
     };
+    message?: string;
 }
 export interface PreviewRequest {
     definition: string;
     references?: Reference[];
 }
 export interface Reference {
-    location?: string;
     content?: string;
+    location?: string;
 }
 export interface VersionRequest {
-    documentation: string;
+    auto_create_documentation?: boolean;
+    branch_name?: string;
     definition: string;
-    hub?: string;
+    documentation: string;
     documentation_name?: string;
-    auto_create_documentation?: boolean;
+    hub?: string;
+    previous_version_id?: string;
     references?: Reference[];
     unpublished?: boolean;
-    previous_version_id?: string;
-    branch_name?: string;
 }
 export interface VersionResponse {
-    id: string;
     doc_public_url?: string;
+    id: string;
 }
 export interface WithDiff {
+    diff_breaking?: boolean;
+    diff_details?: DiffItem[];
+    diff_markdown?: string;
     diff_public_url?: string;
     diff_summary?: string;
-    diff_markdown?: string;
-    diff_details?: DiffItem[];
-    diff_breaking?: boolean;
 }
 export interface DiffRequest {
     definition: string;
-    references?: Reference[];
+    expires_at?: string;
     previous_definition: string;
     previous_references?: Reference[];
-    expires_at?: string;
+    references?: Reference[];
 }
 export interface DiffResponse {
-    id: string;
-    public_url?: string;
     breaking?: boolean;
-    text?: string;
-    markdown?: string;
     details?: DiffItem[];
     html?: string;
+    id: string;
+    markdown?: string;
+    public_url?: string;
+    text?: string;
 }
 export interface DiffItem {
+    breaking: boolean;
+    children: DiffItem[];
     id: string;
     name: string;
     status: string;
     type: string;
-    breaking: boolean;
-    children: DiffItem[];
 }