@botpress/cli 4.17.14 → 4.17.16

package/dist/tables/tables-publisher.d.ts

@@ -0,0 +1,22 @@
+import * as sdk from '@botpress/sdk';
+import * as apiUtils from '../api';
+import * as logger from '../logger';
+import * as utils from '../utils';
+export declare class TablesPublisher {
+    private readonly _api;
+    private readonly _logger;
+    private readonly _prompt;
+    constructor({ api, logger, prompt, }: {
+        api: apiUtils.ApiClient;
+        logger: logger.Logger;
+        prompt: utils.prompt.CLIPrompt;
+    });
+    deployTables({ botId, botDefinition }: {
+        botId: string;
+        botDefinition: sdk.BotDefinition;
+    }): Promise<void>;
+    private _deployExistingTable;
+    private _parseTableColumns;
+    private _warnAndConfirm;
+    private _deployNewTable;
+}

package/dist/typings.d.ts

@@ -0,0 +1,27 @@
+import type { default as yargs, YargsConfig, YargsSchema } from '@bpinternal/yargs-extra';
+export type CommandPositionalOption = yargs.PositionalOptions & {
+    positional: true;
+    idx: number;
+};
+export type CommandNamedOption = YargsSchema[string] & {
+    positional?: false;
+};
+export type CommandOption = CommandPositionalOption | CommandNamedOption;
+export type CommandSchema = Record<string, CommandOption>;
+export type CommandArgv<C extends CommandDefinition = CommandDefinition> = YargsConfig<C['schema']> & {
+    /**
+     * Ignored: fixes weird typing issue
+     */
+    _?: string;
+};
+export type CommandDefinition<S extends CommandSchema = CommandSchema> = {
+    schema: S;
+    description?: string;
+    alias?: string;
+};
+export type CommandImplementation<C extends CommandDefinition = CommandDefinition> = (argv: CommandArgv<C>) => Promise<{
+    exitCode: number;
+}>;
+export type CommandLeaf<C extends CommandDefinition = CommandDefinition> = C & {
+    handler: CommandImplementation<C>;
+};

package/dist/utils/attribute-utils.d.ts

@@ -0,0 +1,10 @@
+type ItemsWithAttributes = Record<string, {
+    attributes?: {
+        [key: string]: string | null;
+    };
+} | null>;
+export declare const prepareAttributeUpdateBody: <TLocalItems extends ItemsWithAttributes>({ localItems, remoteItems, }: {
+    localItems: TLocalItems;
+    remoteItems: ItemsWithAttributes;
+}) => TLocalItems;
+export {};

package/dist/utils/cache-utils.d.ts

@@ -0,0 +1,14 @@
+export declare class FSKeyValueCache<T extends Object> {
+    private _filepath;
+    private _initialized;
+    constructor(_filepath: string);
+    init(): Promise<void>;
+    sync<K extends keyof T>(key: K, value: T[K] | undefined, prompt: (initial?: T[K]) => Promise<T[K]>): Promise<T[K]>;
+    has<K extends keyof T>(key: K): Promise<boolean>;
+    get<K extends keyof T>(key: K): Promise<T[K] | undefined>;
+    set<K extends keyof T>(key: K, value: T[K]): Promise<void>;
+    rm<K extends keyof T>(key: K): Promise<void>;
+    clear(): Promise<void>;
+    private _writeJSON;
+    private _readJSON;
+}

package/dist/utils/case-utils.d.ts

@@ -0,0 +1,14 @@
+export declare const to: {
+    pascalCase: (text: string) => string;
+    kebabCase: (text: string) => string;
+    snakeCase: (text: string) => string;
+    screamingSnakeCase: (text: string) => string;
+    camelCase: (text: string) => string;
+};
+export declare const is: {
+    pascalCase: (text: string) => boolean;
+    kebabCase: (text: string) => boolean;
+    snakeCase: (text: string) => boolean;
+    screamingSnakeCase: (text: string) => boolean;
+    camelCase: (text: string) => boolean;
+};

package/dist/utils/case-utils.test.d.ts

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

package/dist/utils/concurrency-utils.d.ts

@@ -0,0 +1 @@
+export declare const debounceAsync: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, ms: number) => ((...args: TArgs) => Promise<TReturn>);

package/dist/utils/concurrency-utils.test.d.ts

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

package/dist/utils/esbuild-utils.d.ts

@@ -0,0 +1,29 @@
+import * as esb from 'esbuild';
+export * from 'esbuild';
+type BaseProps = {
+    absWorkingDir: string;
+};
+export type BuildCodeProps = BaseProps & {
+    code: string;
+    outfile: string;
+};
+export type BuildEntrypointProps = BaseProps & {
+    entrypoint: string;
+};
+export declare class IncrementalBuildContext {
+    private _context;
+    private _previousProps;
+    private _previousOpts;
+    private _createContext;
+    rebuild(props: BuildCodeProps, opts?: esb.BuildOptions): Promise<void>;
+}
+/**
+ * Bundles a string of typescript code and writes the output to a file
+ */
+export declare function buildCode(props: BuildCodeProps, opts?: esb.BuildOptions): Promise<esb.BuildResult>;
+/**
+ * Bundles a typescript file and returns the output as a string
+ */
+export declare function buildEntrypoint(props: BuildEntrypointProps, opts?: esb.BuildOptions): Promise<esb.BuildResult & {
+    outputFiles: esb.OutputFile[];
+}>;

package/dist/utils/event-emitter.d.ts

@@ -0,0 +1,7 @@
+export declare class EventEmitter<E extends object> {
+    private _listeners;
+    emit<K extends keyof E>(type: K, event: E[K]): void;
+    once<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    on<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+    off<K extends keyof E>(type: K, listener: (event: E[K]) => void): void;
+}

package/dist/utils/file-watcher.d.ts

@@ -0,0 +1,17 @@
+import watcher from '@parcel/watcher';
+export type FileChangeHandler = (events: watcher.Event[]) => Promise<void>;
+type FileWatcherOptions = watcher.Options & {
+    debounceMs?: number;
+};
+/**
+ * Wraps the Parcel file watcher to ensure errors can be catched in an async/await fashion
+ */
+export declare class FileWatcher {
+    private _subscription;
+    private _errorEmitter;
+    static watch(dir: string, fn: FileChangeHandler, opt?: FileWatcherOptions): Promise<FileWatcher>;
+    private constructor();
+    close(): Promise<void>;
+    wait: () => Promise<unknown>;
+}
+export {};

package/dist/utils/guard-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const is: {
+    defined: <T>(value: T | undefined) => value is T;
+    notNull: <T>(value: T | null) => value is T;
+};

package/dist/utils/id-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidID(id: string): boolean;
+export declare function isPrefixedULID(id: string): boolean;

package/dist/utils/index.d.ts

@@ -0,0 +1,22 @@
+export * as attributes from './attribute-utils';
+export * as cache from './cache-utils';
+export * as casing from './case-utils';
+export * as emitter from './event-emitter';
+export * as esbuild from './esbuild-utils';
+export * as filewatcher from './file-watcher';
+export * as guards from './guard-utils';
+export * as id from './id-utils';
+export * as object from './object-utils';
+export * as path from './path-utils';
+export * as pkgJson from './pkgjson-utils';
+export * as promises from './promise-utils';
+export * as prompt from './prompt-utils';
+export * as records from './record-utils';
+export * as require from './require-utils';
+export * as schema from './schema-utils';
+export * as semver from './semver-utils';
+export * as string from './string-utils';
+export * as template from './template-utils';
+export * as tunnel from './tunnel-utils';
+export * as types from './type-utils';
+export * as url from './url-utils';

package/dist/utils/object-utils.d.ts

@@ -0,0 +1 @@
+export declare const omit: <O extends object, K extends keyof O>(obj: O, property: K) => Omit<O, K>;

package/dist/utils/path-utils.d.ts

@@ -0,0 +1,28 @@
+export declare namespace posix {
+    type AbsolutePath = `/${string}`;
+    const isPath: (path: string) => boolean;
+    const isRelativePath: (path: string) => boolean;
+    const isAbsolutePath: (path: string) => path is AbsolutePath;
+}
+export declare namespace win32 {
+    type AbsolutePath = `${string}:\\${string}`;
+    const isPath: (path: string) => boolean;
+    const isRelativePath: (path: string) => boolean;
+    const isAbsolutePath: (path: string) => path is AbsolutePath;
+}
+export type AbsolutePath = posix.AbsolutePath | win32.AbsolutePath;
+export declare const isPath: (path: string) => boolean;
+export declare const isPlatformSpecificPath: (path: string) => boolean;
+export declare const isPlatformSpecificAbsolutePath: (path: string) => path is AbsolutePath;
+export declare const cwd: () => AbsolutePath;
+export declare const join: (abs: AbsolutePath, ...paths: string[]) => AbsolutePath;
+export declare const rmExtension: (filename: string) => string;
+export declare const toUnix: (path: string) => string;
+export declare const toNormalizedPosixPath: (path: string) => string;
+export declare const absoluteFrom: (rootdir: AbsolutePath, target: string) => AbsolutePath;
+export declare const relativeFrom: (rootdir: AbsolutePath, target: string) => string;
+export declare class PathStore<P extends string> {
+    readonly abs: Record<P, AbsolutePath>;
+    constructor(abs: Record<P, AbsolutePath>);
+    rel(from: Extract<P, `${string}Dir`>): Record<P, AbsolutePath> extends infer T extends object ? { [P_1 in keyof T]: string; } : never;
+}

package/dist/utils/path-utils.test.d.ts

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

package/dist/utils/pkgjson-utils.d.ts

@@ -0,0 +1,17 @@
+type JSON = string | number | boolean | null | JSON[] | {
+    [key: string]: JSON;
+};
+export type PackageJson = {
+    name: string;
+    version?: string;
+    description?: string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+} & {
+    [key: string]: JSON;
+};
+export declare const readPackageJson: (path: string) => Promise<PackageJson | undefined>;
+export declare const findDependency: (pkgJson: PackageJson, name: string) => string | undefined;
+export {};

package/dist/utils/promise-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const awaitRecord: <T>(record: Record<string, Promise<T>>) => Promise<Record<string, T>>;
+export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/utils/promise-utils.test.d.ts

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

package/dist/utils/prompt-utils.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from '../logger';
+export type CLIPromptsProps = {
+    confirm: boolean;
+};
+type ChoiceValueType = string | number;
+export type CLIPromptsChoice<V extends ChoiceValueType> = {
+    title: string;
+    value: V;
+};
+type PasswordOptions = Partial<{
+    default: string | undefined;
+    initial: string;
+}>;
+type SelectOptions<V extends ChoiceValueType> = Partial<{
+    default: V | undefined;
+    initial: CLIPromptsChoice<V>;
+    choices: CLIPromptsChoice<V>[];
+}>;
+type TextOptions = Partial<{
+    default: string | undefined;
+    initial: string;
+}>;
+export declare class CLIPrompt {
+    private _props;
+    private _logger;
+    constructor(_props: CLIPromptsProps, _logger: Logger);
+    confirm(message: string): Promise<boolean>;
+    password(message: string, opts?: PasswordOptions): Promise<string | undefined>;
+    select<V extends ChoiceValueType = string>(message: string, opts?: SelectOptions<V>): Promise<V | undefined>;
+    text(message: string, opts?: TextOptions): Promise<string | undefined>;
+    private _prompts;
+}
+export {};

package/dist/utils/record-utils.d.ts

@@ -0,0 +1,8 @@
+export declare const setNullOnMissingValues: <A, B>(record?: Record<string, A>, oldRecord?: Record<string, B>) => Record<string, A | null>;
+export declare const zipObjects: <A, B>(recordA: Record<string, A>, recordB: Record<string, B>) => Record<string, [A | null, B | null]>;
+export declare const mapValues: <A, B>(record: Record<string, A>, fn: (value: A, key: string) => B) => Record<string, B>;
+export declare const mapValuesAsync: <A, B>(record: Record<string, A>, fn: (value: A, key: string) => Promise<B>) => Promise<Record<string, B>>;
+export declare const mapKeys: <A>(record: Record<string, A>, fn: (value: A, key: string) => string) => Record<string, A>;
+export declare function filterValues<A, B extends A>(record: Record<string, A>, fn: (value: A, key: string) => value is B): Record<string, B>;
+export declare function filterValues<A, _B extends A>(record: Record<string, A>, fn: (value: A, key: string) => boolean): Record<string, A>;
+export declare const mergeRecords: <K extends string, V>(a: Record<K, V>, b: Record<K, V>, merge: (v1: V, v2: V) => V) => Record<K, V>;

package/dist/utils/record-utils.test.d.ts

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

package/dist/utils/require-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const requireJsFile: <T>(path: string) => T;
+export declare const requireJsCode: <T>(code: string) => T;

package/dist/utils/require-utils.test.d.ts

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

package/dist/utils/schema-utils.d.ts

@@ -0,0 +1,13 @@
+import * as sdk from '@botpress/sdk';
+import { JSONSchema7 } from 'json-schema';
+type SchemaOptions = {
+    title?: string;
+    examples?: any[];
+};
+type SchemaDefinition = {
+    schema: sdk.ZuiObjectOrRefSchema;
+    ui?: Record<string, SchemaOptions | undefined>;
+};
+export declare function mapZodToJsonSchema(definition: SchemaDefinition): Promise<ReturnType<typeof sdk.transforms.toJSONSchemaLegacy>>;
+export declare const dereferenceSchema: (schema: JSONSchema7) => Promise<JSONSchema7>;
+export {};

package/dist/utils/schema-utils.test.d.ts

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

package/dist/utils/semver-utils.d.ts

@@ -0,0 +1,8 @@
+import semver from 'semver';
+export declare namespace releases {
+    const eq: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const gt: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const gte: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const lt: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+    const lte: (a: semver.ReleaseType, b: semver.ReleaseType) => boolean;
+}

package/dist/utils/string-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const splitOnce: (text: string, separator: string) => [string, string | undefined];
+export declare function chunkString(input: string, chunkSize: number): Generator<string, void, void>;

package/dist/utils/template-utils.d.ts

@@ -0,0 +1 @@
+export declare const formatHandleBars: (templateStr: string, data: Record<string, string>) => string;

package/dist/utils/tunnel-utils.d.ts

@@ -0,0 +1,49 @@
+import { TunnelTail, ClientCloseEvent, ClientErrorEvent } from '@bpinternal/tunnel';
+import { Logger } from '../logger';
+import { EventEmitter } from './event-emitter';
+export type ReconnectionTriggerEvent = {
+    type: 'init';
+    ev: null;
+} | {
+    type: 'error';
+    ev: ClientErrorEvent;
+} | {
+    type: 'close';
+    ev: ClientCloseEvent;
+};
+export type ReconnectedEvent = {
+    tunnel: TunnelTail;
+    ev: ReconnectionTriggerEvent;
+};
+export declare class ReconnectionFailedError extends Error {
+    readonly event: ReconnectionTriggerEvent;
+    constructor(event: ReconnectionTriggerEvent);
+    private static _reason;
+}
+export declare class TunnelSupervisor {
+    private _tunnelUrl;
+    private _tunnelId;
+    private _logger;
+    private _tunnel?;
+    private _closed;
+    private _started;
+    readonly events: EventEmitter<{
+        connectionFailed: ReconnectionTriggerEvent;
+        manuallyClosed: null;
+        connected: {
+            tunnel: TunnelTail;
+            ev: ReconnectionTriggerEvent;
+        };
+    }>;
+    constructor(_tunnelUrl: string, _tunnelId: string, _logger: Logger);
+    start(): Promise<void>;
+    get closed(): boolean;
+    /**
+     * @returns Promise that rejects when a reconnection attempt fails and resolves when the tunnel is closed manually
+     */
+    wait(): Promise<void>;
+    close(): void;
+    private _reconnectSync;
+    private _reconnect;
+    private _registerListeners;
+}

package/dist/utils/type-utils.d.ts

@@ -0,0 +1,19 @@
+export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B;
+export type SafeOmit<T, K extends keyof T> = Omit<T, K>;
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type AssertNever<_T extends never> = true;
+export type AssertExtends<_A extends B, B> = true;
+export type AssertKeyOf<_K extends keyof T, T> = true;
+export type AssertTrue<_T extends true> = true;
+export type AssertAll<_T extends true[]> = true;
+export type IsExtend<X, Y> = X extends Y ? true : false;
+export type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false;
+export type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>;
+type NormalizeObject<T extends object> = T extends infer O ? {
+    [K in keyof O]: Normalize<O[K]>;
+} : never;
+export type Normalize<T> = T extends (...args: infer A) => infer R ? (...args: Normalize<A>) => Normalize<R> : T extends Array<infer E> ? Array<Normalize<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<Normalize<E>> : T extends Promise<infer R> ? Promise<Normalize<R>> : T extends Buffer ? Buffer : T extends object ? NormalizeObject<T> : T;
+export {};

package/dist/utils/url-utils.d.ts

@@ -0,0 +1,19 @@
+declare const _PROTOCOLS: readonly ["http", "https", "ws", "wss"];
+export type Protocol = (typeof _PROTOCOLS)[number];
+export type Path = `/${string}`;
+export type Url = {
+    protocol: Protocol;
+    host: string;
+    port?: number;
+    path?: Path;
+};
+export type UrlParseResult = {
+    status: 'success';
+    url: Url;
+} | {
+    status: 'error';
+    error: string;
+};
+export declare function parse(hostOrUrl: string): UrlParseResult;
+export declare const format: (url: Url) => string;
+export {};

package/dist/worker/child-entrypoint.d.ts

@@ -0,0 +1 @@
+export declare const ENTRY_POINT: string;

package/dist/worker/child-wrapper.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from '../logger';
+import { Config } from './config';
+export type ChildOutput = {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+};
+/**
+ * Wrapper above child_process.ChildProcess to simplify usage
+ */
+export declare class ChildProcessWrapper {
+    private _child;
+    private _exitPromise;
+    static spawn(config: Config, logger: Logger): Promise<ChildProcessWrapper>;
+    private _exited;
+    private constructor();
+    kill(): Promise<ChildOutput>;
+    listen(): Promise<ChildOutput>;
+}

package/dist/worker/config.d.ts

@@ -0,0 +1,28 @@
+import { z } from '@botpress/sdk';
+export declare const CONFIG_ENV_KEY = "CHILD_PROCESS_CONFIGURATION";
+export type Config = z.infer<typeof configSchema>;
+export declare const configSchema: import("@botpress/sdk").ZodUnion<[import("@botpress/sdk").ZodObject<{
+    type: import("@botpress/sdk").ZodLiteral<"code">;
+    code: import("@botpress/sdk").ZodString;
+    env: import("@botpress/sdk").ZodOptional<import("@botpress/sdk").ZodRecord<import("@botpress/sdk").ZodString, import("@botpress/sdk").ZodString>>;
+}, "strip", {
+    type: "code";
+    code: string;
+    env?: Record<string, string> | undefined;
+}, {
+    type: "code";
+    code: string;
+    env?: Record<string, string> | undefined;
+}>, import("@botpress/sdk").ZodObject<{
+    type: import("@botpress/sdk").ZodLiteral<"file">;
+    file: import("@botpress/sdk").ZodString;
+    env: import("@botpress/sdk").ZodOptional<import("@botpress/sdk").ZodRecord<import("@botpress/sdk").ZodString, import("@botpress/sdk").ZodString>>;
+}, "strip", {
+    type: "file";
+    file: string;
+    env?: Record<string, string> | undefined;
+}, {
+    type: "file";
+    file: string;
+    env?: Record<string, string> | undefined;
+}>]>;

package/dist/worker/index.d.ts

@@ -0,0 +1,2 @@
+export { Config } from './config';
+export { Worker } from './worker';

package/dist/worker/is-child.d.ts

@@ -0,0 +1,14 @@
+export declare const CHILD_ENV_KEY = "IS_CHILD";
+export declare const CHILD_ENV_VALUE = "true";
+export type MainProcessProps = {
+    type: 'main';
+    pid: number;
+};
+export type ChildProcessProps = {
+    type: 'child';
+    sendMessage: (message: string) => void;
+    pid: number;
+};
+export type ProcessProps = MainProcessProps | ChildProcessProps;
+export declare const processProps: ProcessProps;
+export declare const isChildProcess: boolean;

package/dist/worker/worker-state.d.ts

@@ -0,0 +1,30 @@
+import type { ChildProcessWrapper } from './child-wrapper';
+export type WorkerStatus = WorkerState['status'];
+export type WorkerState = {
+    status: 'errored';
+    thrown: unknown;
+} | {
+    status: 'dead';
+    murdered: boolean;
+} | {
+    status: 'killing';
+} | {
+    status: 'reloading';
+} | {
+    status: 'live';
+    child: ChildProcessWrapper;
+};
+export type StateOf<S extends WorkerStatus> = Extract<WorkerState, {
+    status: S;
+}>;
+export type WorkerStateHandler<S extends WorkerStatus> = (state: StateOf<S>) => void;
+export declare class WorkerStateObserver {
+    private _state;
+    private _handlers;
+    constructor(initialState: WorkerState);
+    waitFor<S extends WorkerStatus>(status: S): Promise<void>;
+    on<S extends WorkerStatus>(status: S, handler: WorkerStateHandler<S>): void;
+    off<S extends WorkerStatus>(status: S, handler: WorkerStateHandler<S>): void;
+    get(): WorkerState;
+    set(newState: WorkerState): void;
+}

package/dist/worker/worker.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '../logger';
+import type { Config } from './config';
+export type WorkerProps = {
+    hangOnExit?: boolean;
+};
+export declare class Worker {
+    private _config;
+    private _logger;
+    private _props;
+    static spawn(config: Config, logger: Logger, props?: Partial<WorkerProps>): Promise<Worker>;
+    private _state;
+    private constructor();
+    /**
+     * Used to determine if the worker can be killed
+     */
+    get running(): boolean;
+    kill: () => Promise<import("./child-wrapper").ChildOutput>;
+    reload: () => Promise<void>;
+    wait: () => Promise<void>;
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@botpress/cli",
-  "version": "4.17.14",
+  "version": "4.17.16",
   "description": "Botpress CLI",
   "scripts": {
-    "build": "pnpm run bundle && pnpm run template:gen",
-    "dev": "ts-node -T src/index.ts",
-    "start": "node dist/index.js",
+    "build": "pnpm run build:types && pnpm run bundle && pnpm run template:gen",
+    "dev": "ts-node -T src/cli.ts",
+    "start": "node dist/cli.js",
     "check:type": "tsc --noEmit",
     "bundle": "ts-node -T build.ts",
+    "build:types": "tsc -p ./tsconfig.build.json",
     "template:gen": "pnpm -r --stream -F @bp-templates/* exec bp gen",
     "test:e2e": "ts-node -T ./e2e"
   },
@@ -18,6 +19,7 @@
     "bp": "./bin.js"
   },
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.0",
     "@botpress/chat": "0.5.1",

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "emitDeclarationOnly": true,
+    "noCheck": true
+  },
+  "include": ["./src/**/*"]
+}