@botpress/cli 4.17.14 → 4.17.15

package/dist/linter/rulesets/integration.ruleset.d.ts

@@ -0,0 +1,390 @@
+export declare const INTEGRATION_RULESET: {
+    extends: never[];
+    rules: {
+        'integration-title-must-be-present': {
+            description: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'integration-description-must-be-present': {
+            description: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'integration-must-have-an-icon': {
+            description: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'integration-must-have-a-readme-file': {
+            description: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'actions-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'actions-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-inputparams-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-inputparams-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-outputparams-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-outputparams-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'event-outputparams-should-have-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'event-outputparams-must-have-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'events-must-have-a-title': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'events-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'consider-migrating-to-configurations': {
+            description: string;
+            severity: "off";
+            given: string;
+            then: {
+                field: string;
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'configuration-fields-must-have-a-title': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'configuration-fields-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'multiple-configurations-must-have-a-title': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'multiple-configurations-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'multipes-configurations-fields-must-have-a-title': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'multipes-configurations-fields-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'user-tags-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'user-tags-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'channels-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'channels-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'channels-conversation-tags-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'channels-conversation-tags-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'channels-message-tags-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'channels-message-tags-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'legacy-zui-title-should-be-removed': {
+            description: string;
+            severity: "error";
+            given: string;
+            then: {
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'legacy-zui-examples-should-be-removed': {
+            description: string;
+            severity: "hint";
+            given: string;
+            then: {
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'state-fields-should-have-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'state-fields-must-have-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'secrets-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+    };
+};

package/dist/linter/rulesets/interface.ruleset.d.ts

@@ -0,0 +1,141 @@
+export declare const INTERFACE_RULESET: {
+    extends: never[];
+    rules: {
+        'action-inputparams-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-inputparams-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-outputparams-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'action-outputparams-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'event-outputparams-should-have-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'event-outputparams-must-have-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'legacy-zui-title-should-be-removed': {
+            description: string;
+            severity: "error";
+            given: string;
+            then: {
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'legacy-zui-examples-should-be-removed': {
+            description: string;
+            severity: "hint";
+            given: string;
+            then: {
+                function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<unknown, null>;
+            }[];
+        };
+        'entities-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'entities-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'entity-fields-should-have-a-title': {
+            description: string;
+            message: string;
+            severity: "warn";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+        'entity-fields-must-have-a-description': {
+            description: string;
+            message: string;
+            severity: "error";
+            given: string;
+            then: {
+                field: string;
+                function: (input: string, _: unknown, context: import("@stoplight/spectral-core").RulesetFunctionContext) => {
+                    message: string;
+                }[];
+            }[];
+        };
+    };
+};

package/dist/linter/spectral-functions.d.ts

@@ -0,0 +1,11 @@
+import { RulesetFunctionContext } from '@stoplight/spectral-core';
+type MessageFn = ({ path }: {
+    path: (string | number)[];
+}) => string;
+/**
+ * When the input is falsy, return a message that is generated by the provided function
+ */
+export declare const truthyWithMessage: (fn: MessageFn) => (input: string, _: unknown, context: RulesetFunctionContext) => {
+    message: string;
+}[];
+export {};

package/dist/logger/base-logger.d.ts

@@ -0,0 +1,43 @@
+export type LoggerOptions = {
+    verbose: boolean;
+    json: boolean;
+    outStream: NodeJS.WriteStream;
+    errStream: NodeJS.WriteStream;
+};
+type Symbol = '✓' | '⚠' | '×' | '●' | ' ' | '○';
+type Color = 'blue' | 'green' | 'yellow' | 'red' | 'pink' | 'white' | 'orange' | 'purple';
+type LogPrefix = {
+    symbol: Symbol;
+    fg?: Color;
+    bg?: Color;
+    indent?: number;
+} | string;
+type LogProps = {
+    prefix: LogPrefix;
+    stderr?: boolean;
+};
+type PrintProps = {
+    metadata: any;
+    prefix: string;
+    stderr?: boolean;
+};
+export type StreamType = 'out' | 'err';
+export declare abstract class BaseLogger {
+    protected opts: LoggerOptions;
+    constructor(opts?: Partial<LoggerOptions>);
+    log(message: string, props?: Partial<LogProps>): void;
+    json(data: any, opts?: Partial<{
+        depth: number;
+    }>): void;
+    debug(message: string): void;
+    started(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    box(message: string): void;
+    protected abstract print(message: string, props?: Partial<PrintProps>): void;
+    private _resolvePrefix;
+    private _renderSymbol;
+    protected render(message: string, streamType?: StreamType): void;
+}
+export {};

package/dist/logger/index.d.ts

@@ -0,0 +1,22 @@
+import { BaseLogger } from './base-logger';
+export declare class Logger extends BaseLogger {
+    private static _previousLine;
+    protected print(message: string, props?: Partial<{
+        prefix: string;
+        stderr?: boolean;
+    }>): void;
+    line(): _SingleLineLogger;
+    cleanup(): void;
+}
+/**
+ * Prints to a single line unless it is committed.
+ * When committed or if the stream is not TTY, it prints normally using new lines.
+ */
+declare class _SingleLineLogger extends BaseLogger {
+    private _commited;
+    commit(): void;
+    protected print(message: string, props?: Partial<{
+        prefix: string;
+    }>): void;
+}
+export {};

package/dist/logger/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/package-ref.d.ts

@@ -0,0 +1,22 @@
+import * as sdk from '@botpress/sdk';
+type PackageType = sdk.Package['type'];
+export type UUIDPackageRef = {
+    type: 'id';
+    id: string;
+};
+export type NamePackageRef = {
+    type: 'name';
+    pkg?: PackageType;
+    name: string;
+    version: string;
+};
+export type LocalPackageRef = {
+    type: 'path';
+    path: string;
+};
+export type ApiPackageRef = UUIDPackageRef | NamePackageRef;
+export type PackageRef = ApiPackageRef | LocalPackageRef;
+export declare const LATEST_TAG = "latest";
+export declare const formatPackageRef: (ref: PackageRef) => string;
+export declare const parsePackageRef: (ref: string) => PackageRef | undefined;
+export {};

package/dist/package-ref.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/project-templates.d.ts

@@ -0,0 +1,42 @@
+import * as utils from './utils';
+export declare namespace ProjectTemplates {
+    type Template = Readonly<{
+        fullName: string;
+        identifier: string;
+        defaultProjectName: string;
+        absolutePath: utils.path.AbsolutePath;
+    }>;
+    type TemplateArray = Readonly<[Template, ...Template[]]>;
+    type ProjectType = 'bot' | 'plugin' | 'integration';
+    const templates: {
+        readonly bot: readonly [{
+            readonly fullName: "Empty Bot";
+            readonly identifier: "empty";
+            readonly defaultProjectName: "empty-bot";
+            readonly absolutePath: utils.path.AbsolutePath;
+        }];
+        readonly plugin: readonly [{
+            readonly fullName: "Empty Plugin";
+            readonly identifier: "empty";
+            readonly defaultProjectName: "empty-plugin";
+            readonly absolutePath: utils.path.AbsolutePath;
+        }];
+        readonly integration: readonly [{
+            readonly fullName: "Empty Integration";
+            readonly identifier: "empty";
+            readonly defaultProjectName: "empty-integration";
+            readonly absolutePath: utils.path.AbsolutePath;
+        }, {
+            readonly fullName: "Hello World";
+            readonly identifier: "hello-world";
+            readonly defaultProjectName: "hello-world";
+            readonly absolutePath: utils.path.AbsolutePath;
+        }, {
+            readonly fullName: "Webhook Message";
+            readonly identifier: "webhook-message";
+            readonly defaultProjectName: "webhook-message";
+            readonly absolutePath: utils.path.AbsolutePath;
+        }];
+    };
+    const getAllChoices: () => ("empty" | "hello-world" | "webhook-message")[];
+}

package/dist/register-yargs.d.ts

@@ -0,0 +1,4 @@
+import yargs from '@bpinternal/yargs-extra';
+import * as tree from './command-tree';
+export type YargsInstance = typeof yargs;
+export declare const registerYargs: (yargz: YargsInstance, commands: tree.CommandTree) => void;