@botpress/sdk 2.5.0 → 3.0.0

package/dist/integration/client/types.d.ts

@@ -1,7 +1,8 @@
 import * as client from '@botpress/client';
 import * as utils from '../../utils/type-utils';
 import * as common from '../types';
-type GetChannelByName<TIntegration extends common.BaseIntegration, TChannelName extends keyof TIntegration['channels']> = utils.Cast<TIntegration['channels'][TChannelName], common.ChannelDefinition>;
+type BaseChannelDefinition = common.BaseIntegration['channels'][string];
+type GetChannelByName<TIntegration extends common.BaseIntegration, TChannelName extends keyof TIntegration['channels']> = utils.Cast<TIntegration['channels'][TChannelName], BaseChannelDefinition>;
 /**
  * @deprecated Integration's should no longer use their name as prefix for event types or tags.
  */

package/dist/integration/definition/index.d.ts

@@ -1,16 +1,11 @@
 import type * as esbuild from 'esbuild';
 import { InterfacePackage } from '../../package';
+import * as utils from '../../utils';
 import { z } from '../../zui';
 import { SchemaStore, BrandedSchema } from './branded-schema';
 import { BaseConfig, BaseEvents, BaseActions, BaseChannels, BaseStates, BaseEntities, BaseConfigs } from './generic';
-import { ConfigurationDefinition, EventDefinition, ChannelDefinition, ActionDefinition, StateDefinition, UserDefinition, SecretDefinition, EntityDefinition, AdditionalConfigurationDefinition } from './types';
+import { ConfigurationDefinition, EventDefinition, ChannelDefinition, ActionDefinition, StateDefinition, UserDefinition, SecretDefinition, EntityDefinition, AdditionalConfigurationDefinition, InterfaceExtension } from './types';
 export * from './types';
-export type InterfaceExtension = InterfacePackage & {
-    entities: Record<string, {
-        name: string;
-        schema: z.AnyZodObject;
-    }>;
-};
 export type IntegrationDefinitionProps<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TConfigs extends BaseConfigs = BaseConfigs, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TChannels extends BaseChannels = BaseChannels, TStates extends BaseStates = BaseStates, TEntities extends BaseEntities = BaseEntities> = {
     name: TName;
     version: TVersion;
@@ -51,11 +46,47 @@ export type IntegrationDefinitionProps<TName extends string = string, TVersion e
 type EntitiesOfPackage<TPackage extends InterfacePackage> = {
     [K in keyof TPackage['definition']['entities']]: NonNullable<TPackage['definition']['entities']>[K]['schema'];
 };
-type ExtensionBuilderInput<TIntegrationEntities extends BaseEntities> = SchemaStore<TIntegrationEntities>;
-type ExtensionBuilderOutput<TInterfaceEntities extends BaseEntities> = {
-    [K in keyof TInterfaceEntities]: BrandedSchema<z.ZodSchema<z.infer<TInterfaceEntities[K]>>>;
+type ActionsOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['actions']]: NonNullable<TPackage['definition']['actions']>[K]['input']['schema'];
+};
+type EventsOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['events']]: NonNullable<TPackage['definition']['events']>[K]['schema'];
+};
+type ChannelsOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['channels']]: {
+        [M in keyof NonNullable<TPackage['definition']['channels']>[K]['messages']]: NonNullable<NonNullable<TPackage['definition']['channels']>[K]['messages']>[M]['schema'];
+    };
+};
+export type ActionOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<ActionDefinition>, 'title' | 'description' | 'billable' | 'cacheable'> & {
+    name: string;
+}>;
+export type EventOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<EventDefinition>, 'title' | 'description'> & {
+    name: string;
+}>;
+export type ChannelOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<ChannelDefinition>, 'title' | 'description'> & {
+    name: string;
+    message: {
+        tags: Required<Required<ChannelDefinition>['message']>['tags'];
+    };
+    conversation: {
+        tags: Required<Required<ChannelDefinition>['conversation']>['tags'];
+    };
+}>;
+type ActionOverrides<TInterfaceActionNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceActionNames, ActionOverrideProps>>;
+type EventOverrides<TInterfaceEventNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceEventNames, EventOverrideProps>>;
+type ChannelOverrides<TInterfaceChannelNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceChannelNames, ChannelOverrideProps>>;
+type ExtensionBuilderInput<TIntegrationEntities extends BaseEntities, _TIntegrationActions extends BaseActions, _TIntegrationEvents extends BaseEvents, _TIntegrationChannels extends BaseChannels> = {
+    entities: SchemaStore<TIntegrationEntities>;
+};
+type ExtensionBuilderOutput<TInterfaceEntities extends BaseEntities, TInterfaceActions extends BaseActions, TInterfaceEvents extends BaseEvents, TInterfaceChannels extends BaseChannels> = {
+    entities: {
+        [K in keyof TInterfaceEntities]: BrandedSchema<z.ZodSchema<z.infer<TInterfaceEntities[K]>>>;
+    };
+    actions?: ActionOverrides<Extract<keyof TInterfaceActions, string>>;
+    events?: EventOverrides<Extract<keyof TInterfaceEvents, string>>;
+    channels?: ChannelOverrides<Extract<keyof TInterfaceChannels, string>>;
 };
-type ExtensionBuilder<TIntegrationEntities extends BaseEntities, TInterfaceEntities extends BaseEntities> = (input: ExtensionBuilderInput<TIntegrationEntities>) => ExtensionBuilderOutput<TInterfaceEntities>;
+type ExtensionBuilder<TIntegrationEntities extends BaseEntities, TIntegrationActions extends BaseActions, TIntegrationEvents extends BaseEvents, TIntegrationChannels extends BaseChannels, TInterfaceEntities extends BaseEntities, TInterfaceActions extends BaseActions, TInterfaceEvents extends BaseEvents, TInterfaceChannels extends BaseChannels> = (input: ExtensionBuilderInput<TIntegrationEntities, TIntegrationActions, TIntegrationEvents, TIntegrationChannels>) => ExtensionBuilderOutput<TInterfaceEntities, TInterfaceActions, TInterfaceEvents, TInterfaceChannels>;
 export declare class IntegrationDefinition<TName extends string = string, TVersion extends string = string, TConfig extends BaseConfig = BaseConfig, TConfigs extends BaseConfigs = BaseConfigs, TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions, TChannels extends BaseChannels = BaseChannels, TStates extends BaseStates = BaseStates, TEntities extends BaseEntities = BaseEntities> {
     readonly props: IntegrationDefinitionProps<TName, TVersion, TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>;
     readonly name: this['props']['name'];
@@ -77,5 +108,10 @@ export declare class IntegrationDefinition<TName extends string = string, TVersi
     readonly interfaces: this['props']['interfaces'];
     readonly __advanced: this['props']['__advanced'];
     constructor(props: IntegrationDefinitionProps<TName, TVersion, TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>);
-    extend<P extends InterfacePackage>(interfacePkg: P, builder: ExtensionBuilder<TEntities, EntitiesOfPackage<P>>): this;
+    extend<P extends InterfacePackage>(interfacePkg: P, builder: ExtensionBuilder<TEntities, TActions, TEvents, TChannels, EntitiesOfPackage<P>, ActionsOfPackage<P>, EventsOfPackage<P>, ChannelsOfPackage<P>>): this;
+    private _callBuilder;
+    private _mergeActions;
+    private _mergeEvents;
+    private _mergeChannels;
+    private _mergeMessage;
 }

package/dist/integration/definition/types.d.ts

@@ -80,7 +80,12 @@ export type ResolvedInterface<TEvents extends BaseEvents = BaseEvents, TActions
         [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
     };
 };
-export type InterfaceImplementationStatement<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents, TChannels extends BaseChannels = BaseChannels> = {
+/**
+ * A.K.A. Interface Implementation Statetement
+ * Used by an integration to explicitly declare that it implements an interface
+ */
+export type InterfaceExtension<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents, TChannels extends BaseChannels = BaseChannels> = {
+    id?: string;
     name: string;
     version: string;
     entities: {

package/dist/integration/index.d.ts

@@ -2,4 +2,4 @@ export * from './definition';
 export * from './implementation';
 export * from './client';
 export * from './server';
-export * from './types/generic';
+export * from './types';

package/dist/integration/types/common.d.ts

@@ -1,11 +1,4 @@
 import * as utils from '../../utils/type-utils';
-import { BaseIntegration } from './generic';
-export type ConfigurationDefinition = BaseIntegration['configuration'];
-export type ActionDefinition = BaseIntegration['actions'][string];
-export type ChannelDefinition = BaseIntegration['channels'][string];
-export type EventDefinition = BaseIntegration['events'][string];
-export type StateDefinition = BaseIntegration['states'][string];
-export type UserDefinition = BaseIntegration['user'];
 type AsTags<T extends Record<string, string | undefined>> = utils.Cast<T, Record<string, string>>;
 export type ToTags<TTags extends string | number | symbol> = AsTags<Partial<Record<utils.Cast<TTags, string>, string>>>;
 export {};

package/dist/interface/definition.d.ts

@@ -45,7 +45,6 @@ export type InterfaceDefinitionProps<TName extends string = string, TVersion ext
     channels?: {
         [K in keyof TChannels]: GenericChannelDefinition<TEntities, TChannels[K]>;
     };
-    templateName?: string;
 };
 export declare class InterfaceDefinition<TName extends string = string, TVersion extends string = string, TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents, TChannels extends BaseChannels = BaseChannels> {
     readonly props: InterfaceDefinitionProps<TName, TVersion, TEntities, TActions, TEvents, TChannels>;
@@ -63,7 +62,6 @@ export declare class InterfaceDefinition<TName extends string = string, TVersion
     readonly channels: {
         [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
     };
-    readonly templateName: this['props']['templateName'];
     constructor(props: InterfaceDefinitionProps<TName, TVersion, TEntities, TActions, TEvents, TChannels>);
     private _getEntityReference;
 }

package/dist/interface/index.d.ts

@@ -1 +1,2 @@
 export * from './definition';
+export * from './types';

package/dist/interface/resolve.d.ts

@@ -0,0 +1,18 @@
+import { ActionOverrideProps, ChannelOverrideProps, EventOverrideProps, InterfaceExtension, ResolvedInterface } from '../integration';
+import { InterfacePackage } from '../package';
+import { ZuiObjectSchema } from '../zui';
+type ResolveInterfaceInput = InterfacePackage & {
+    entities: Record<string, {
+        name: string;
+        schema: ZuiObjectSchema;
+    }>;
+    actions: Record<string, ActionOverrideProps>;
+    events: Record<string, EventOverrideProps>;
+    channels: Record<string, ChannelOverrideProps>;
+};
+type ResolveInterfaceOutput = {
+    resolved: ResolvedInterface;
+    statement: InterfaceExtension;
+};
+export declare const resolveInterface: (intrface: ResolveInterfaceInput) => ResolveInterfaceOutput;
+export {};

package/dist/interface/types/index.d.ts

@@ -0,0 +1 @@
+export * from './generic';

package/dist/package.d.ts

@@ -1,5 +1,6 @@
 import * as integration from './integration';
 import * as plugin from './plugin';
+import * as utils from './utils/type-utils';
 type NameVersion = {
     name: string;
     version: string;
@@ -8,6 +9,7 @@ type PackageReference = NameVersion & {
     id?: string;
     uri?: string;
 };
+type IntegrationPackageDefinitionInterface = utils.Merge<PackageReference, integration.InterfaceExtension>;
 type IntegrationPackageDefinition = NameVersion & {
     configuration?: integration.ConfigurationDefinition;
     configurations?: Record<string, integration.AdditionalConfigurationDefinition>;
@@ -18,10 +20,9 @@ type IntegrationPackageDefinition = NameVersion & {
     user?: integration.UserDefinition;
     secrets?: Record<string, integration.SecretDefinition>;
     entities?: Record<string, integration.EntityDefinition>;
-    interfaces?: Record<string, PackageReference>;
+    interfaces?: Record<string, IntegrationPackageDefinitionInterface>;
 };
 type InterfacePackageDefinition = NameVersion & {
-    templateName?: string;
     entities?: Record<string, integration.EntityDefinition>;
     events?: Record<string, integration.EventDefinition>;
     actions?: Record<string, integration.ActionDefinition>;
@@ -38,6 +39,7 @@ type PluginPackageDefinition = NameVersion & {
     events?: Record<string, plugin.EventDefinition>;
     recurringEvents?: Record<string, plugin.RecurringEventDefinition>;
     actions?: Record<string, plugin.ActionDefinition>;
+    tables?: Record<string, plugin.TableDefinition>;
 };
 export type IntegrationPackage = PackageReference & {
     type: 'integration';

package/dist/plugin/action-proxy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './proxy';
+export * from './types';

package/dist/plugin/action-proxy/proxy.d.ts

@@ -0,0 +1,5 @@
+import { Client } from '@botpress/client';
+import { BotSpecificClient } from '../../bot';
+import { BasePlugin, PluginInterfaceExtensions } from '../types';
+import { ActionProxy } from './types';
+export declare const proxyActions: <TPlugin extends BasePlugin>(client: BotSpecificClient<TPlugin> | Client, interfaces: PluginInterfaceExtensions<TPlugin>) => ActionProxy<TPlugin>;

package/dist/plugin/action-proxy/types.d.ts

@@ -0,0 +1,14 @@
+import * as utils from '../../utils/type-utils';
+import { BasePlugin } from '../types';
+type IntegrationActionProxy<TPlugin extends BasePlugin> = {
+    [TIntegrationName in keyof TPlugin['integrations']]: {
+        [TActionName in keyof TPlugin['integrations'][TIntegrationName]['actions']]: (input: TPlugin['integrations'][TIntegrationName]['actions'][TActionName]['input']) => Promise<TPlugin['integrations'][TIntegrationName]['actions'][TActionName]['output']>;
+    };
+};
+type InterfacesActionProxy<TPlugin extends BasePlugin> = {
+    [TInterfaceName in keyof TPlugin['interfaces']]: {
+        [TActionName in keyof TPlugin['interfaces'][TInterfaceName]['actions']]: (input: TPlugin['interfaces'][TInterfaceName]['actions'][TActionName]['input']) => Promise<TPlugin['interfaces'][TInterfaceName]['actions'][TActionName]['output']>;
+    };
+};
+export type ActionProxy<TPlugin extends BasePlugin> = utils.Normalize<IntegrationActionProxy<TPlugin> & InterfacesActionProxy<TPlugin>>;
+export {};

package/dist/plugin/action-proxy/types.test.d.ts

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

package/dist/plugin/definition.d.ts

@@ -1,14 +1,15 @@
-import { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition } from '../bot/definition';
+import { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition } 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';
+export { StateDefinition, RecurringEventDefinition, EventDefinition, ConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition, TableDefinition, 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> = {
+type BaseTables = Record<string, ZuiObjectSchema>;
+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, TTables extends BaseTables = BaseTables> = {
     name: TName;
     version: TVersion;
     integrations?: {
@@ -31,9 +32,12 @@ export type PluginDefinitionProps<TName extends string = string, TVersion extend
     actions?: {
         [K in keyof TActions]: ActionDefinition<TActions[K]>;
     };
+    tables?: {
+        [K in keyof TTables]: TableDefinition<TTables[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>;
+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, TTables extends BaseTables = BaseTables> {
+    readonly props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables>;
     readonly name: this['props']['name'];
     readonly version: this['props']['version'];
     readonly integrations: this['props']['integrations'];
@@ -46,5 +50,6 @@ export declare class PluginDefinition<TName extends string = string, TVersion ex
     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>);
+    readonly tables: this['props']['tables'];
+    constructor(props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables>);
 }

package/dist/plugin/implementation.d.ts

@@ -1,28 +1,30 @@
-import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookHandlersMap, HookData, HookHandlers, ActionHandlers, BotHandlers } from './server/types';
-import { BasePlugin } from './types/generic';
+import { MessageHandlersMap as BotMessageHandlersMap, EventHandlersMap as BotEventHandlersMap, StateExpiredHandlersMap as BotStateExpiredHandlersMap, HookHandlersMap as BotHookHandlersMap, ActionHandlers as BotActionHandlers, BotHandlers } from '../bot';
+import { MessageHandlersMap, MessageHandlers, EventHandlersMap, EventHandlers, StateExpiredHandlersMap, StateExpiredHandlers, HookData, HookHandlers, ActionHandlers, PluginConfiguration } from './server/types';
+import { BasePlugin, PluginInterfaceExtensions } from './types';
 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;
-        };
-    };
+    configuration: PluginConfiguration<TPlugin>;
+    interfaces: PluginInterfaceExtensions<TPlugin>;
 };
 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>;
+    private _actionHandlers;
+    private _messageHandlers;
+    private _eventHandlers;
+    private _stateExpiredHandlers;
+    private _hookHandlers;
     constructor(props: PluginImplementationProps<TPlugin>);
     initialize(config: PluginRuntimeProps<TPlugin>): this;
-    get config(): PluginRuntimeProps<TPlugin>;
+    private get _runtime();
+    private _getTools;
+    get actionHandlers(): BotActionHandlers<TPlugin>;
+    get messageHandlers(): BotMessageHandlersMap<TPlugin>;
+    get eventHandlers(): BotEventHandlersMap<TPlugin>;
+    get stateExpiredHandlers(): BotStateExpiredHandlersMap<TPlugin>;
+    get hookHandlers(): BotHookHandlersMap<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;
@@ -36,4 +38,8 @@ export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugi
         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;
     };
+    /**
+     * checks if the actual event resolves to the target event
+     */
+    private _eventResolvesTo;
 }

package/dist/plugin/index.d.ts

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

package/dist/plugin/interface-resolution.d.ts

@@ -0,0 +1,15 @@
+import { PluginInterfaceExtensions } from './types';
+export type ParsedActionRef = {
+    namespace: string;
+    actionName: string;
+};
+export type ParsedEventRef = {
+    namespace: string;
+    eventName: string;
+};
+export declare const parseActionRef: (actionRef: string) => ParsedActionRef | null;
+export declare const parseEventRef: (eventRef: string) => ParsedEventRef | null;
+export declare const formatActionRef: (actionRef: ParsedActionRef) => string;
+export declare const formatEventRef: (eventRef: ParsedEventRef) => string;
+export declare const resolveAction: (actionRef: ParsedActionRef, interfaces: PluginInterfaceExtensions<any>) => ParsedActionRef;
+export declare const resolveEvent: (eventRef: ParsedEventRef, interfaces: PluginInterfaceExtensions<any>) => ParsedEventRef;

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

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

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

@@ -1 +1,241 @@
-export * from '../../bot/server/types';
+import * as client from '@botpress/client';
+import * as bot from '../../bot';
+import * as utils from '../../utils/type-utils';
+import * as proxy from '../action-proxy';
+import * as types from '../types';
+type EnumeratePluginEvents<TPlugin extends types.BasePlugin> = bot.EnumerateEvents<TPlugin> & types.EnumerateInterfaceEvents<TPlugin>;
+type _IncomingEvents<TPlugin extends types.BasePlugin> = {
+    [K in keyof EnumeratePluginEvents<TPlugin>]: utils.Merge<client.Event, {
+        type: K;
+        payload: EnumeratePluginEvents<TPlugin>[K];
+    }>;
+};
+type _IncomingMessages<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.GetMessages<TPlugin>]: utils.Merge<client.Message, {
+        type: K;
+        payload: bot.GetMessages<TPlugin>[K];
+    }>;
+};
+type _IncomingStates<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.EnumerateStates<TPlugin>]: utils.Merge<client.State, {
+        name: K;
+        payload: bot.EnumerateStates<TPlugin>[K];
+    }>;
+};
+type _OutgoingMessageRequests<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.GetMessages<TPlugin>]: utils.Merge<client.ClientInputs['createMessage'], {
+        type: K;
+        payload: bot.GetMessages<TPlugin>[K];
+    }>;
+};
+type _OutgoingMessageResponses<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.GetMessages<TPlugin>]: utils.Merge<client.ClientOutputs['createMessage'], {
+        message: utils.Merge<client.Message, {
+            type: K;
+            payload: bot.GetMessages<TPlugin>[K];
+        }>;
+    }>;
+};
+type _OutgoingCallActionRequests<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.EnumerateActionInputs<TPlugin>]: utils.Merge<client.ClientInputs['callAction'], {
+        type: K;
+        input: bot.EnumerateActionInputs<TPlugin>[K];
+    }>;
+};
+type _OutgoingCallActionResponses<TPlugin extends types.BasePlugin> = {
+    [K in keyof bot.EnumerateActionOutputs<TPlugin>]: utils.Merge<client.ClientOutputs['callAction'], {
+        output: bot.EnumerateActionOutputs<TPlugin>[K];
+    }>;
+};
+export type AnyIncomingEvent<_TPlugin extends types.BasePlugin> = client.Event;
+export type AnyIncomingMessage<_TPlugin extends types.BasePlugin> = client.Message;
+export type AnyOutgoingMessageRequest<_TPlugin extends types.BasePlugin> = client.ClientInputs['createMessage'];
+export type AnyOutgoingMessageResponse<_TPlugin extends types.BasePlugin> = client.ClientOutputs['createMessage'];
+export type AnyOutgoingCallActionRequest<_TPlugin extends types.BasePlugin> = client.ClientInputs['callAction'];
+export type AnyOutgoingCallActionResponse<_TPlugin extends types.BasePlugin> = client.ClientOutputs['callAction'];
+export type IncomingEvents<TPlugin extends types.BasePlugin> = _IncomingEvents<TPlugin> & {
+    '*': AnyIncomingEvent<TPlugin>;
+};
+export type IncomingMessages<TPlugin extends types.BasePlugin> = _IncomingMessages<TPlugin> & {
+    '*': AnyIncomingMessage<TPlugin>;
+};
+export type IncomingStates<_TPlugin extends types.BasePlugin> = _IncomingStates<_TPlugin> & {
+    '*': client.State;
+};
+export type OutgoingMessageRequests<TPlugin extends types.BasePlugin> = _OutgoingMessageRequests<TPlugin> & {
+    '*': AnyOutgoingMessageRequest<TPlugin>;
+};
+export type OutgoingMessageResponses<TPlugin extends types.BasePlugin> = _OutgoingMessageResponses<TPlugin> & {
+    '*': AnyOutgoingMessageResponse<TPlugin>;
+};
+export type OutgoingCallActionRequests<TPlugin extends types.BasePlugin> = _OutgoingCallActionRequests<TPlugin> & {
+    '*': AnyOutgoingCallActionRequest<TPlugin>;
+};
+export type OutgoingCallActionResponses<TPlugin extends types.BasePlugin> = _OutgoingCallActionResponses<TPlugin> & {
+    '*': AnyOutgoingCallActionResponse<TPlugin>;
+};
+export type PluginClient<_TPlugin extends types.BasePlugin> = bot.BotSpecificClient<types.BasePlugin>;
+export type PluginConfiguration<TPlugin extends types.BasePlugin> = TPlugin['configuration'];
+export type CommonHandlerProps<TPlugin extends types.BasePlugin> = {
+    ctx: bot.BotContext;
+    logger: bot.BotLogger;
+    client: PluginClient<TPlugin>;
+    configuration: PluginConfiguration<TPlugin>;
+    interfaces: types.PluginInterfaceExtensions<TPlugin>;
+    actions: proxy.ActionProxy<TPlugin>;
+};
+export type MessagePayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingMessages<TPlugin>]: CommonHandlerProps<TPlugin> & {
+        message: IncomingMessages<TPlugin>[K];
+        user: client.User;
+        conversation: client.Conversation;
+        event: client.Event;
+        states: {
+            [TState in keyof TPlugin['states']]: {
+                type: 'user' | 'conversation' | 'bot';
+                payload: TPlugin['states'][TState];
+            };
+        };
+    };
+};
+export type MessageHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingMessages<TPlugin>]: (args: MessagePayloads<TPlugin>[K]) => Promise<void>;
+};
+export type EventPayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingEvents<TPlugin>]: CommonHandlerProps<TPlugin> & {
+        event: IncomingEvents<TPlugin>[K];
+    };
+};
+export type EventHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingEvents<TPlugin>]: (args: EventPayloads<TPlugin>[K]) => Promise<void>;
+};
+export type StateExpiredPayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingStates<TPlugin>]: CommonHandlerProps<TPlugin> & {
+        state: IncomingStates<TPlugin>[K];
+    };
+};
+export type StateExpiredHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof IncomingStates<TPlugin>]: (args: StateExpiredPayloads<TPlugin>[K]) => Promise<void>;
+};
+export type ActionHandlerPayloads<TPlugin extends types.BasePlugin> = {
+    [K in keyof TPlugin['actions']]: CommonHandlerProps<TPlugin> & {
+        type?: K;
+        input: TPlugin['actions'][K]['input'];
+    };
+};
+export type ActionHandlers<TPlugin extends types.BasePlugin> = {
+    [K in keyof TPlugin['actions']]: (props: ActionHandlerPayloads<TPlugin>[K]) => Promise<TPlugin['actions'][K]['output']>;
+};
+type BaseHookDefinition = {
+    stoppable?: boolean;
+    data: any;
+};
+type HookDefinition<THookDef extends BaseHookDefinition = BaseHookDefinition> = THookDef;
+/**
+ * TODO: add hooks for:
+ *   - before_register
+ *   - after_register
+ *   - before_state_expired
+ *   - after_state_expired
+ *   - before_incoming_call_action
+ *   - after_incoming_call_action
+ */
+export type HookDefinitionType = keyof HookDefinitions<types.BasePlugin>;
+export type HookDefinitions<TPlugin extends types.BasePlugin> = {
+    before_incoming_event: HookDefinition<{
+        stoppable: true;
+        data: _IncomingEvents<TPlugin> & {
+            '*': AnyIncomingEvent<TPlugin>;
+        };
+    }>;
+    before_incoming_message: HookDefinition<{
+        stoppable: true;
+        data: _IncomingMessages<TPlugin> & {
+            '*': AnyIncomingMessage<TPlugin>;
+        };
+    }>;
+    before_outgoing_message: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingMessageRequests<TPlugin> & {
+            '*': AnyOutgoingMessageRequest<TPlugin>;
+        };
+    }>;
+    before_outgoing_call_action: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingCallActionRequests<TPlugin> & {
+            '*': AnyOutgoingCallActionRequest<TPlugin>;
+        };
+    }>;
+    after_incoming_event: HookDefinition<{
+        stoppable: true;
+        data: _IncomingEvents<TPlugin> & {
+            '*': AnyIncomingEvent<TPlugin>;
+        };
+    }>;
+    after_incoming_message: HookDefinition<{
+        stoppable: true;
+        data: _IncomingMessages<TPlugin> & {
+            '*': AnyIncomingMessage<TPlugin>;
+        };
+    }>;
+    after_outgoing_message: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingMessageResponses<TPlugin> & {
+            '*': AnyOutgoingMessageResponse<TPlugin>;
+        };
+    }>;
+    after_outgoing_call_action: HookDefinition<{
+        stoppable: false;
+        data: _OutgoingCallActionResponses<TPlugin> & {
+            '*': AnyOutgoingCallActionResponse<TPlugin>;
+        };
+    }>;
+};
+export type HookData<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookDefinitions<TPlugin>]: {
+        [T in keyof HookDefinitions<TPlugin>[H]['data']]: HookDefinitions<TPlugin>[H]['data'][T];
+    };
+};
+export type HookInputs<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]: CommonHandlerProps<TPlugin> & {
+            data: HookData<TPlugin>[H][T];
+        };
+    };
+};
+export type HookOutputs<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]: {
+            data?: HookData<TPlugin>[H][T];
+        } & (HookDefinitions<TPlugin>[H]['stoppable'] extends true ? {
+            stop?: boolean;
+        } : {});
+    };
+};
+export type HookHandlers<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]: (input: HookInputs<TPlugin>[H][T]) => Promise<HookOutputs<TPlugin>[H][T] | undefined>;
+    };
+};
+export type MessageHandlersMap<TPlugin extends types.BasePlugin> = {
+    [T in keyof IncomingMessages<TPlugin>]?: MessageHandlers<TPlugin>[T][];
+};
+export type EventHandlersMap<TPlugin extends types.BasePlugin> = {
+    [T in keyof IncomingEvents<TPlugin>]?: EventHandlers<TPlugin>[T][];
+};
+export type StateExpiredHandlersMap<TPlugin extends types.BasePlugin> = {
+    [T in keyof IncomingStates<TPlugin>]?: StateExpiredHandlers<TPlugin>[T][];
+};
+export type HookHandlersMap<TPlugin extends types.BasePlugin> = {
+    [H in keyof HookData<TPlugin>]: {
+        [T in keyof HookData<TPlugin>[H]]?: HookHandlers<TPlugin>[H][T][];
+    };
+};
+export type PluginHandlers<TPlugin extends types.BasePlugin> = {
+    actionHandlers: ActionHandlers<TPlugin>;
+    messageHandlers: MessageHandlersMap<TPlugin>;
+    eventHandlers: EventHandlersMap<TPlugin>;
+    stateExpiredHandlers: StateExpiredHandlersMap<TPlugin>;
+    hookHandlers: HookHandlersMap<TPlugin>;
+};
+export {};