@botpress/sdk 2.0.4 → 2.0.5

package/dist/package.d.ts

@@ -0,0 +1,58 @@
+import * as integration from './integration';
+import * as plugin from './plugin';
+type NameVersion = {
+    name: string;
+    version: string;
+};
+type PackageReference = NameVersion & {
+    id?: string;
+    uri?: string;
+};
+type IntegrationPackageDefinition = NameVersion & {
+    configuration?: integration.ConfigurationDefinition;
+    configurations?: Record<string, integration.AdditionalConfigurationDefinition>;
+    events?: Record<string, integration.EventDefinition>;
+    actions?: Record<string, integration.ActionDefinition>;
+    channels?: Record<string, integration.ChannelDefinition>;
+    states?: Record<string, integration.StateDefinition>;
+    user?: integration.UserDefinition;
+    secrets?: Record<string, integration.SecretDefinition>;
+    entities?: Record<string, integration.EntityDefinition>;
+    interfaces?: Record<string, PackageReference>;
+};
+type InterfacePackageDefinition = NameVersion & {
+    templateName?: string;
+    entities?: Record<string, integration.EntityDefinition>;
+    events?: Record<string, integration.EventDefinition>;
+    actions?: Record<string, integration.ActionDefinition>;
+    channels?: Record<string, integration.ChannelDefinition>;
+};
+type PluginPackageDefinition = NameVersion & {
+    integrations?: Record<string, PackageReference>;
+    interfaces?: Record<string, PackageReference>;
+    user?: plugin.UserDefinition;
+    conversation?: plugin.ConversationDefinition;
+    message?: plugin.MessageDefinition;
+    states?: Record<string, plugin.StateDefinition>;
+    configuration?: plugin.ConfigurationDefinition;
+    events?: Record<string, plugin.EventDefinition>;
+    recurringEvents?: Record<string, plugin.RecurringEventDefinition>;
+    actions?: Record<string, plugin.ActionDefinition>;
+};
+export type IntegrationPackage = PackageReference & {
+    type: 'integration';
+    definition: IntegrationPackageDefinition;
+    implementation?: null;
+};
+export type InterfacePackage = PackageReference & {
+    type: 'interface';
+    definition: InterfacePackageDefinition;
+    implementation?: null;
+};
+export type PluginPackage = PackageReference & {
+    type: 'plugin';
+    definition: PluginPackageDefinition;
+    implementation: Buffer;
+};
+export type Package = IntegrationPackage | InterfacePackage | PluginPackage;
+export {};

package/dist/plugin/definition.d.ts

@@ -0,0 +1,50 @@
+import { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition } from '../bot/definition';
+import { IntegrationPackage, InterfacePackage } from '../package';
+import { ZuiObjectSchema } from '../zui';
+export { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, IntegrationConfigInstance, } from '../bot/definition';
+type BaseConfig = ZuiObjectSchema;
+type BaseStates = Record<string, ZuiObjectSchema>;
+type BaseEvents = Record<string, ZuiObjectSchema>;
+type BaseActions = Record<string, ZuiObjectSchema>;
+type BaseInterfaces = Record<string, any>;
+type BaseIntegrations = Record<string, any>;
+export type PluginDefinitionProps<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations> = {
+    name: TName;
+    version: TVersion;
+    integrations?: {
+        [K in keyof TIntegrations]: IntegrationPackage;
+    };
+    interfaces?: {
+        [K in keyof TInterfaces]: InterfacePackage;
+    };
+    user?: UserDefinition;
+    conversation?: ConversationDefinition;
+    message?: MessageDefinition;
+    states?: {
+        [K in keyof TStates]: StateDefinition<TStates[K]>;
+    };
+    configuration?: ConfigurationDefinition<TConfig>;
+    events?: {
+        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+    };
+    recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
+    actions?: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+};
+export declare class PluginDefinition<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TStates extends BaseStates = BaseStates, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TInterfaces extends BaseInterfaces = BaseInterfaces, TIntegrations extends BaseIntegrations = BaseIntegrations> {
+    readonly props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations>;
+    readonly name: this['props']['name'];
+    readonly version: this['props']['version'];
+    readonly integrations: this['props']['integrations'];
+    readonly interfaces: this['props']['interfaces'];
+    readonly user: this['props']['user'];
+    readonly conversation: this['props']['conversation'];
+    readonly message: this['props']['message'];
+    readonly states: this['props']['states'];
+    readonly configuration: this['props']['configuration'];
+    readonly events: this['props']['events'];
+    readonly recurringEvents: this['props']['recurringEvents'];
+    readonly actions: this['props']['actions'];
+    constructor(props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations>);
+}

package/dist/plugin/implementation.d.ts

@@ -0,0 +1,39 @@
+import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookHandlersMap, HookData, HookHandlers, ActionHandlers, BotHandlers } from './server/types';
+import { BasePlugin } from './types/generic';
+export type PluginImplementationProps<TPlugin extends BasePlugin = BasePlugin> = {
+    actions: ActionHandlers<TPlugin>;
+};
+export type PluginRuntimeProps<TPlugin extends BasePlugin = BasePlugin> = {
+    configuration: TPlugin['configuration'];
+    interfaces: {
+        [K in keyof TPlugin['interfaces']]: {
+            name: string;
+            version: string;
+        };
+    };
+};
+export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugin> implements BotHandlers<TPlugin> {
+    readonly props: PluginImplementationProps<TPlugin>;
+    private _runtimeProps;
+    readonly actionHandlers: ActionHandlers<TPlugin>;
+    readonly messageHandlers: MessageHandlersMap<TPlugin>;
+    readonly eventHandlers: EventHandlersMap<TPlugin>;
+    readonly stateExpiredHandlers: StateExpiredHandlersMap<TPlugin>;
+    readonly hookHandlers: HookHandlersMap<TPlugin>;
+    constructor(props: PluginImplementationProps<TPlugin>);
+    initialize(config: PluginRuntimeProps<TPlugin>): this;
+    get config(): PluginRuntimeProps<TPlugin>;
+    readonly on: {
+        message: <T extends keyof MessageHandlersMap<TPlugin>>(type: T, handler: MessageHandlers<TPlugin>[T]) => void;
+        event: <T extends keyof EventHandlersMap<TPlugin>>(type: T, handler: EventHandlers<TPlugin>[T]) => void;
+        stateExpired: <T extends keyof StateExpiredHandlersMap<TPlugin>>(type: T, handler: StateExpiredHandlers<TPlugin>[T]) => void;
+        beforeIncomingEvent: <T extends keyof HookData<TPlugin>["before_incoming_event"]>(type: T, handler: HookHandlers<TPlugin>["before_incoming_event"][T]) => void;
+        beforeIncomingMessage: <T extends keyof HookData<TPlugin>["before_incoming_message"]>(type: T, handler: HookHandlers<TPlugin>["before_incoming_message"][T]) => void;
+        beforeOutgoingMessage: <T extends keyof HookData<TPlugin>["before_outgoing_message"]>(type: T, handler: HookHandlers<TPlugin>["before_outgoing_message"][T]) => void;
+        beforeOutgoingCallAction: <T extends keyof HookData<TPlugin>["before_outgoing_call_action"]>(type: T, handler: HookHandlers<TPlugin>["before_outgoing_call_action"][T]) => void;
+        afterIncomingEvent: <T extends keyof HookData<TPlugin>["after_incoming_event"]>(type: T, handler: HookHandlers<TPlugin>["after_incoming_event"][T]) => void;
+        afterIncomingMessage: <T extends keyof HookData<TPlugin>["after_incoming_message"]>(type: T, handler: HookHandlers<TPlugin>["after_incoming_message"][T]) => void;
+        afterOutgoingMessage: <T extends keyof HookData<TPlugin>["after_outgoing_message"]>(type: T, handler: HookHandlers<TPlugin>["after_outgoing_message"][T]) => void;
+        afterOutgoingCallAction: <T extends keyof HookData<TPlugin>["after_outgoing_call_action"]>(type: T, handler: HookHandlers<TPlugin>["after_outgoing_call_action"][T]) => void;
+    };
+}

package/dist/plugin/index.d.ts

@@ -0,0 +1,3 @@
+export * from './definition';
+export * from './implementation';
+export * from './types/generic';

package/dist/plugin/server/types.d.ts

@@ -0,0 +1 @@
+export * from '../../bot/server/types';

package/dist/plugin/server/types.test.d.ts

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

package/dist/plugin/types/generic.d.ts

@@ -0,0 +1,30 @@
+import { BaseIntegration, DefaultIntegration, InputBaseIntegration } from '../../integration/types/generic';
+import { BaseInterface, InputBaseInterface, DefaultInterface } from '../../interface/types/generic';
+import * as utils from '../../utils/type-utils';
+export type BaseAction = {
+    input: any;
+    output: any;
+};
+export type BasePlugin = {
+    configuration: any;
+    integrations: Record<string, BaseIntegration>;
+    interfaces: Record<string, BaseInterface>;
+    events: Record<string, any>;
+    states: Record<string, any>;
+    actions: Record<string, BaseAction>;
+    unknownDefinitions: true;
+};
+export type InputBasePlugin = utils.DeepPartial<BasePlugin>;
+export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
+    configuration: utils.Default<B['configuration'], BasePlugin['configuration']>;
+    events: utils.Default<B['events'], BasePlugin['events']>;
+    states: utils.Default<B['states'], BasePlugin['states']>;
+    actions: utils.Default<B['actions'], BasePlugin['actions']>;
+    unknownDefinitions: utils.Default<B['unknownDefinitions'], BasePlugin['unknownDefinitions']>;
+    integrations: undefined extends B['integrations'] ? BasePlugin['integrations'] : {
+        [K in keyof B['integrations']]: DefaultIntegration<utils.Cast<B['integrations'][K], InputBaseIntegration>>;
+    };
+    interfaces: undefined extends B['interfaces'] ? BasePlugin['interfaces'] : {
+        [K in keyof B['interfaces']]: DefaultInterface<utils.Cast<B['interfaces'][K], InputBaseInterface>>;
+    };
+};

package/dist/plugin/types/generic.test.d.ts

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

package/dist/retry.d.ts

@@ -0,0 +1,2 @@
+import { RetryConfig } from '@botpress/client';
+export declare const retryConfig: RetryConfig;

package/dist/schema.d.ts

@@ -0,0 +1,18 @@
+import * as z from './zui';
+type SchemaOptions<T> = {
+    title: string;
+    examples: T[];
+};
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+type UiDefinition<TSchema extends z.ZuiObjectSchema = z.ZuiObjectSchema> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
+    [K in keyof z.infer<TSchema>]: Partial<SchemaOptions<z.infer<TSchema>[K]>>;
+};
+export type SchemaDefinition<TSchema extends z.ZuiObjectSchema = z.ZuiObjectSchema> = {
+    schema: TSchema;
+    /**
+     * @deprecated
+     * Use zod.Schema.displayAs() instead
+     **/
+    ui?: Partial<UiDefinition<TSchema>>;
+};
+export {};

package/dist/serve.d.ts

@@ -0,0 +1,20 @@
+import { Server } from 'node:http';
+export type Request = {
+    body?: string;
+    path: string;
+    query: string;
+    method: string;
+    headers: {
+        [key: string]: string | undefined;
+    };
+};
+export type Response = {
+    body?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    status?: number;
+};
+export type Handler = (req: Request) => Promise<Response | void>;
+export declare function parseBody<T>(req: Request): T;
+export declare function serve(handler: Handler, port?: number, callback?: (port: number) => void): Promise<Server>;

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

@@ -0,0 +1 @@
+export declare const safePush: <T>(arr: T[] | undefined, ...values: T[]) => T[];

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * as records from './record-utils';
+export * as arrays from './array-utils';
+export * as types from './type-utils';

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

@@ -0,0 +1,3 @@
+export declare const pairs: <K extends string, V>(obj: Record<K, V>) => [K, V][];
+export declare const values: <K extends string, V>(obj: Record<K, V>) => V[];
+export declare const mapValues: <K extends string, V, R>(obj: Record<K, V>, fn: (value: V, key: K) => R) => Record<K, R>;

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

@@ -0,0 +1,33 @@
+export type ValueOf<T> = T[keyof T];
+export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B;
+export type Cast<T, U> = T extends U ? T : U;
+export type SafeCast<T, U> = [T] extends [never] ? U : Cast<T, U>;
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};
+export type Default<T, U> = undefined extends T ? U : T;
+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>>;
+export type AssertExtends<_A extends B, B> = true;
+export type AssertTrue<_T extends true> = true;
+export type AssertAll<_T extends true[]> = true;
+export type Join<S extends (string | number | symbol)[]> = S extends [infer H, ...infer T] ? `${Cast<H, string>}${Join<Cast<T, string[]>>}` : S extends [infer H] ? Cast<H, string> : '';
+export type Split<S extends string | number | symbol, D extends string> = S extends `${infer H}${D}${infer T}` ? [H, ...Split<Cast<T, string>, D>] : [S];
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * removes string index signature from Record
+ */
+export type ToSealedRecord<R extends Record<string, any>> = {
+    [K in keyof R as string extends K ? never : K]: R[K];
+};
+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;
+type DeepPartialObject<T extends object> = T extends infer O ? {
+    [K in keyof O]?: DeepPartial<O[K]>;
+} : never;
+export type DeepPartial<T> = T extends (...args: infer A) => infer R ? (...args: DeepPartial<A>) => DeepPartial<R> : T extends Array<infer E> ? Array<DeepPartial<E>> : T extends ReadonlyArray<infer E> ? ReadonlyArray<DeepPartial<E>> : T extends Promise<infer R> ? Promise<DeepPartial<R>> : T extends Buffer ? Buffer : T extends object ? DeepPartialObject<T> : T;
+export {};

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

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

package/dist/zui.d.ts

@@ -0,0 +1,5 @@
+import { z } from '@bpinternal/zui';
+export * from '@bpinternal/zui';
+export type GenericZuiSchema<A extends Record<string, z.ZodTypeAny> = Record<string, z.ZodTypeAny>, R extends z.ZodTypeAny = z.ZodTypeAny> = (typeArguments: A) => R;
+export type ZuiObjectSchema = z.ZodObject | z.ZodRecord;
+export default z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Botpress SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,7 +14,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@botpress/client": "0.38.0",
+    "@botpress/client": "0.38.1",
     "@bpinternal/zui": "0.12.0"
   },
   "devDependencies": {