@holocronlab/botruntime-sdk 6.13.3

package/dist/package.d.ts

@@ -0,0 +1,64 @@
+import * as integration from './integration';
+import * as plugin from './plugin';
+import * as utils from './utils/type-utils';
+type NameVersion = {
+    name: string;
+    version: string;
+};
+type PackageReference = NameVersion & {
+    id?: string;
+    uri?: string;
+};
+type Attributes = {
+    attributes?: Record<string, string>;
+};
+type IntegrationPackageDefinitionInterface = utils.Merge<PackageReference, integration.InterfaceExtension>;
+type IntegrationPackageDefinition = NameVersion & Attributes & {
+    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, IntegrationPackageDefinitionInterface>;
+};
+type InterfacePackageDefinition = NameVersion & Attributes & {
+    entities?: Record<string, integration.EntityDefinition>;
+    events?: Record<string, integration.EventDefinition>;
+    actions?: Record<string, integration.ActionDefinition>;
+    channels?: Record<string, integration.ChannelDefinition>;
+};
+type PluginPackageDefinition = NameVersion & Attributes & {
+    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>;
+    tables?: Record<string, plugin.TableDefinition>;
+    workflows?: Record<string, plugin.WorkflowDefinition>;
+};
+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/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 '@holocronlab/botruntime-client';
+import { BotSpecificClient } from '../../bot';
+import { BasePlugin, PluginRuntimeProps } from '../common';
+import { ActionProxy } from './types';
+export declare const proxyActions: <TPlugin extends BasePlugin>(client: BotSpecificClient<TPlugin> | Client, props: PluginRuntimeProps<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 '../common';
+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/common/generic.d.ts

@@ -0,0 +1,63 @@
+import * as bot from '../../bot';
+import { BaseIntegration, DefaultIntegration, InputBaseIntegration } from '../../integration/common/generic';
+import { BaseInterface, InputBaseInterface, DefaultInterface } from '../../interface/common/generic';
+import * as utils from '../../utils/type-utils';
+export type BaseAction = {
+    input: any;
+    output: any;
+};
+export type BaseTable = {
+    [k: string]: any;
+};
+export type BaseWorkflow = {
+    input: any;
+    output: any;
+    tags?: {
+        [k: string]: string;
+    };
+};
+export type BaseState = {
+    type: bot.StateType;
+    payload: any;
+};
+export type BasePlugin = {
+    name: string;
+    version: string;
+    configuration: any;
+    integrations: Record<string, BaseIntegration>;
+    interfaces: Record<string, BaseInterface>;
+    events: Record<string, any>;
+    states: Record<string, BaseState>;
+    actions: Record<string, BaseAction>;
+    tables: Record<string, BaseTable>;
+    workflows: Record<string, BaseWorkflow>;
+    conversation: {
+        tags: Record<string, any>;
+    };
+    user: {
+        tags: Record<string, any>;
+    };
+    message: {
+        tags: Record<string, any>;
+    };
+};
+export type InputBasePlugin = utils.DeepPartial<BasePlugin>;
+export type DefaultPlugin<B extends utils.DeepPartial<BasePlugin>> = {
+    name: utils.Default<B['name'], BasePlugin['name']>;
+    version: utils.Default<B['version'], BasePlugin['version']>;
+    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']>;
+    tables: utils.Default<B['tables'], BasePlugin['tables']>;
+    workflows: utils.Default<B['workflows'], BasePlugin['workflows']>;
+    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>>;
+    };
+    conversation: utils.Default<B['conversation'], BasePlugin['conversation']>;
+    user: utils.Default<B['user'], BasePlugin['user']>;
+    message: utils.Default<B['message'], BasePlugin['message']>;
+};

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

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

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

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

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

@@ -0,0 +1,59 @@
+import type { BaseInterface } from '../../interface';
+import type { Cast, Join, UnionToIntersection } from '../../utils/type-utils';
+import type { BasePlugin } from './generic';
+type EventKey<TIntegrationName extends string, TEventName extends string> = string extends TIntegrationName ? string : string extends TEventName ? string : Join<[TIntegrationName, ':', TEventName]>;
+export type EnumerateInterfaceEvents<TPlugin extends BasePlugin> = UnionToIntersection<{
+    [TInterfaceName in keyof TPlugin['interfaces']]: {
+        [TEventName in keyof TPlugin['interfaces'][TInterfaceName]['events'] as EventKey<Cast<TInterfaceName, string>, Cast<TEventName, string>>]: TPlugin['interfaces'][TInterfaceName]['events'][TEventName];
+    };
+}[keyof TPlugin['interfaces']]>;
+/**
+ * Used by a bot to tell the plugin what integration should be used to implement an interface.
+ */
+export type PluginInterfaceExtension<TInterface extends BaseInterface = BaseInterface> = {
+    id?: string;
+    name: string;
+    version: string;
+    integrationAlias: string;
+    integrationInterfaceAlias: string;
+    entities: {
+        [K in keyof TInterface['entities']]: {
+            name: string;
+        };
+    };
+    actions: {
+        [K in keyof TInterface['actions']]: {
+            name: string;
+        };
+    };
+    events: {
+        [K in keyof TInterface['events']]: {
+            name: string;
+        };
+    };
+    channels: {
+        [K in keyof TInterface['channels']]: {
+            name: string;
+        };
+    };
+};
+export type PluginIntegrationExtension = {
+    id?: string;
+    name: string;
+    version: string;
+    integrationAlias: string;
+};
+export type PluginInterfaceExtensions<TPlugin extends BasePlugin = BasePlugin> = {
+    [TPluginInterfaceAlias in keyof TPlugin['interfaces']]: PluginInterfaceExtension<TPlugin['interfaces'][TPluginInterfaceAlias]>;
+};
+export type PluginIntegrationExtensions<TPlugin extends BasePlugin = BasePlugin> = {
+    [TPluginIntegrationAlias in keyof TPlugin['integrations']]: PluginIntegrationExtension;
+};
+export type PluginConfiguration<TPlugin extends BasePlugin> = TPlugin['configuration'];
+export type PluginRuntimeProps<TPlugin extends BasePlugin = BasePlugin> = {
+    alias: string;
+    configuration: PluginConfiguration<TPlugin>;
+    interfaces: PluginInterfaceExtensions<TPlugin>;
+    integrations: PluginIntegrationExtensions<TPlugin>;
+};
+export {};

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

@@ -0,0 +1,2 @@
+export { proxyConversation, proxyConversations } from './proxy';
+export { ActionableConversation, ConversationFinder } from './types';

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

@@ -0,0 +1,13 @@
+import type * as client from '@holocronlab/botruntime-client';
+import type { BotSpecificClient } from '../../bot';
+import type { BasePlugin, PluginRuntimeProps } from '../common';
+import type { ActionableConversation, ConversationFinder } from './types';
+export declare const proxyConversations: <TPlugin extends BasePlugin>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+}) => ConversationFinder<TPlugin>;
+export declare const proxyConversation: <TPlugin extends BasePlugin>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+    conversation: client.Conversation;
+}) => ActionableConversation<TPlugin>;

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

@@ -0,0 +1,54 @@
+import type * as client from '@holocronlab/botruntime-client';
+import type { commonTypes } from '../../common';
+import type { AsyncCollection } from '../../utils/api-paging-utils';
+import type * as typeUtils from '../../utils/type-utils';
+import type { BasePlugin } from '../common';
+import type * as messageProxy from '../message-proxy/types';
+import type * as userProxy from '../user-proxy/types';
+export type ConversationFinder<TPlugin extends BasePlugin> = _ConversationFinderForDepType<TPlugin, 'interfaces'> & _ConversationFinderForDepType<TPlugin, 'integrations'>;
+type _ConversationFinderForDepType<TPlugin extends BasePlugin, TDepType extends 'interfaces' | 'integrations'> = {
+    [TAlias in typeUtils.StringKeys<TPlugin[TDepType]> | '*']: {
+        [TChannelName in TAlias extends '*' ? '*' : typeUtils.StringKeys<TPlugin[TDepType][TAlias]['channels']> | '*']: _ConversationFinderForChannel<TPlugin, TChannelName, _MessageForChannel<TPlugin, TDepType, TAlias extends '*' ? string : TAlias, TChannelName extends '*' ? string : TChannelName>>;
+    };
+};
+type _ConversationFinderForChannel<TPlugin extends BasePlugin, TChannelName extends string, TMessage extends client.Message> = {
+    list: (props?: typeUtils.Merge<Omit<client.ClientInputs['listConversations'], 'integrationName' | 'channel' | 'nextToken'>, {
+        tags?: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+    }>) => AsyncCollection<ActionableConversation<TPlugin, TChannelName extends '*' ? string : TChannelName, TMessage>>;
+    getById: (props: {
+        id: string;
+    }) => Promise<ActionableConversation<TPlugin, TChannelName extends '*' ? string : TChannelName, TMessage>>;
+};
+type _MessageForChannel<TPlugin extends BasePlugin, TDepType extends 'interfaces' | 'integrations', TAlias extends keyof TPlugin[TDepType], TChannelName extends keyof TPlugin[TDepType][TAlias]['channels']> = _FallbackWhenNever<Omit<client.Message, 'type' | 'payload' | 'tags'> & typeUtils.ValueOf<{
+    [TMessageName in typeUtils.StringKeys<TPlugin[TDepType][TAlias]['channels'][TChannelName]['messages']>]: {
+        type: TMessageName;
+        payload: TPlugin[TDepType][TAlias]['channels'][TChannelName]['messages'][TMessageName];
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    };
+}>, typeUtils.Merge<client.Message, {
+    tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+}>>;
+type _FallbackWhenNever<T, TFallback> = [T] extends [never] ? TFallback : T;
+export type ActionableConversation<TPlugin extends BasePlugin, TChannelName extends string = string, TMessage extends client.Message = client.Message> = typeUtils.Merge<client.Conversation, {
+    tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+    channel: TChannelName;
+}> & {
+    delete: () => Promise<void>;
+    update: (props: typeUtils.Merge<Omit<client.ClientInputs['updateConversation'], 'id'>, {
+        tags?: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+    }>) => Promise<ActionableConversation<TPlugin, TChannelName, TMessage>>;
+    getMessage: (props: {
+        id: string;
+    }) => Promise<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    getOrCreateMessage: (props: Omit<client.ClientInputs['getOrCreateMessage'], 'conversationId' | 'tags' | 'type' | 'payload'> & typeUtils.DistributivePick<TMessage, 'type' | 'payload'> & {
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }) => Promise<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    createMessage: (props: Omit<client.ClientInputs['createMessage'], 'conversationId' | 'tags' | 'type' | 'payload'> & typeUtils.DistributivePick<TMessage, 'type' | 'payload'> & {
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }) => Promise<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    listMessages: (props?: typeUtils.Merge<Omit<client.ClientInputs['listMessages'], 'conversationId' | 'nextToken'>, {
+        tags?: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }>) => AsyncCollection<messageProxy.ActionableMessage<TPlugin, TMessage>>;
+    listParticipants: () => AsyncCollection<userProxy.ActionableUser<TPlugin, string>>;
+};
+export {};

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

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

package/dist/plugin/definition.d.ts

@@ -0,0 +1,152 @@
+import { StateDefinition as BotStateDefinition, EventDefinition as BotEventDefinition, ConfigurationDefinition as BotConfigurationDefinition, UserDefinition, ConversationDefinition, MessageDefinition, ActionDefinition as BotActionDefinition, TableDefinition as BotTableDefinition, WorkflowDefinition } from '../bot/definition';
+import { SchemaTransformOptions } from '../common/types';
+import { IntegrationPackage, InterfacePackage } from '../package';
+import * as typeUtils from '../utils/type-utils';
+import { z } from '../zui';
+export { UserDefinition, ConversationDefinition, MessageDefinition, WorkflowDefinition } from '../bot/definition';
+type BaseConfig = z.ZuiObjectOrRefSchema;
+type BaseStates = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseEvents = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseActions = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseInterfaces = Record<string, InterfacePackage>;
+type BaseIntegrations = Record<string, IntegrationPackage>;
+type BaseTables = Record<string, z.ZuiObjectOrRefSchema>;
+type BaseWorkflows = Record<string, z.ZuiObjectSchema>;
+export type TableDefinition<TTable extends BaseTables[string] = BaseTables[string]> = typeUtils.Merge<BotTableDefinition, {
+    schema: TTable;
+}>;
+export type ConfigurationDefinition<TConfig extends BaseConfig = BaseConfig> = typeUtils.Merge<BotConfigurationDefinition, {
+    schema: TConfig;
+}>;
+export type StateDefinition<TState extends BaseStates[string] = BaseStates[string]> = typeUtils.Merge<BotStateDefinition, {
+    schema: TState;
+}>;
+export type EventDefinition<TEvent extends BaseEvents[string] = BaseEvents[string]> = typeUtils.Merge<BotEventDefinition, {
+    schema: TEvent;
+}>;
+export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = typeUtils.Merge<BotActionDefinition, {
+    input: {
+        schema: TAction;
+    };
+    output: {
+        schema: z.ZuiObjectOrRefSchema;
+    };
+}>;
+export type RecurringEventDefinition<TEvents extends BaseEvents = BaseEvents> = {
+    [K in keyof TEvents]: {
+        type: K;
+        payload: z.infer<TEvents[K]>;
+        schedule: {
+            cron: string;
+        };
+    };
+}[keyof TEvents];
+export type ZuiSchemaWithEntityReferences<TInterfaces extends BaseInterfaces, TReturnType extends z.ZuiObjectOrRefSchema> = ((props: {
+    entities: {
+        [TInterfaceAlias in keyof TInterfaces]: {
+            [TEntityName in keyof TInterfaces[TInterfaceAlias]['definition']['entities']]: z.ZodRef;
+        };
+    };
+}) => TReturnType) | TReturnType;
+type GenericDefinition<TInterfaces extends BaseInterfaces, TDefinition extends {
+    schema: z.ZuiObjectOrRefSchema;
+}> = typeUtils.Merge<TDefinition, {
+    schema: ZuiSchemaWithEntityReferences<TInterfaces, TDefinition['schema']>;
+}>;
+type GenericNestedDefinition<TInterfaces extends BaseInterfaces, TDefinition extends {
+    [k: string]: any;
+}, TKeys extends string> = Omit<TDefinition, TKeys> & {
+    [TKey in TKeys]: Omit<TDefinition[TKey], 'schema'> & {
+        schema: ZuiSchemaWithEntityReferences<TInterfaces, TDefinition[TKey]['schema']>;
+    };
+};
+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, TWorkflows extends BaseWorkflows = BaseWorkflows> = {
+    name: TName;
+    version: TVersion;
+    title?: string;
+    description?: string;
+    icon?: string;
+    readme?: string;
+    attributes?: Record<string, string>;
+    integrations?: TIntegrations;
+    interfaces?: TInterfaces;
+    user?: UserDefinition;
+    conversation?: ConversationDefinition;
+    message?: MessageDefinition;
+    states?: {
+        [K in keyof TStates]: GenericDefinition<TInterfaces, StateDefinition<TStates[K]>>;
+    };
+    configuration?: GenericDefinition<TInterfaces, ConfigurationDefinition<TConfig>>;
+    events?: {
+        [K in keyof TEvents]: GenericDefinition<TInterfaces, EventDefinition<TEvents[K]>>;
+    };
+    /** @deprecated Use the `recurrence` field on each event in `events` instead. */
+    recurringEvents?: Record<string, RecurringEventDefinition<TEvents>>;
+    actions?: {
+        [K in keyof TActions]: GenericNestedDefinition<TInterfaces, ActionDefinition<TActions[K]>, 'input' | 'output'>;
+    };
+    tables?: {
+        [K in keyof TTables]: GenericDefinition<TInterfaces, TableDefinition<TTables[K]>>;
+    };
+    /**
+     * # EXPERIMENTAL
+     * This API is experimental and may change in the future.
+     */
+    workflows?: {
+        [K in keyof TWorkflows]: WorkflowDefinition<TWorkflows[K]>;
+    };
+    __advanced?: SchemaTransformOptions;
+};
+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, TWorkflows extends BaseWorkflows = BaseWorkflows> {
+    readonly props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables, TWorkflows>;
+    readonly name: this['props']['name'];
+    readonly version: this['props']['version'];
+    readonly title: this['props']['title'];
+    readonly description: this['props']['description'];
+    readonly icon: this['props']['icon'];
+    readonly readme: this['props']['readme'];
+    readonly attributes: this['props']['attributes'];
+    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: {
+        [K in keyof TStates]: StateDefinition<TStates[K]>;
+    };
+    readonly configuration?: ConfigurationDefinition<TConfig>;
+    readonly events: {
+        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+    };
+    readonly recurringEvents: this['props']['recurringEvents'];
+    readonly actions: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+    readonly tables: {
+        [K in keyof TTables]: TableDefinition<TTables[K]>;
+    };
+    readonly workflows: this['props']['workflows'];
+    readonly __advanced: this['props']['__advanced'];
+    constructor(props: PluginDefinitionProps<TName, TVersion, TConfig, TStates, TEvents, TActions, TInterfaces, TIntegrations, TTables, TWorkflows>);
+    get metadata(): {
+        readonly sdkVersion: string;
+    };
+    readonly clone?: (overrides?: Partial<PluginDefinitionProps>) => PluginDefinition;
+    /**
+     * Returns a copy of the plugin definition where all entity references are
+     * resolved to the base entity schema defined by the interface. This does not
+     * include any additional properties that may be added to the entity by the
+     * backing integration.
+     *
+     * If `intersectWithUnknownRecord` is `true` (default), the entity schemas
+     * will be intersected with `z.record(z.string(), z.unknown())` to make it
+     * explicit that the backing integration may have added additional properties.
+     */
+    dereferenceEntities({ intersectWithUnknownRecord }?: {
+        intersectWithUnknownRecord?: boolean;
+    }): this;
+    private _buildZuiReferenceMap;
+    private _dereferenceZuiSchema;
+    private _dereferenceDefinitionSchemas;
+    private _dereferenceActionDefinitionSchemas;
+}

package/dist/plugin/definition.test.d.ts

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

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

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

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

@@ -0,0 +1,5 @@
+import type * as client from '@holocronlab/botruntime-client';
+import { BotSpecificClient } from '../../bot';
+import { BasePlugin, PluginRuntimeProps } from '../common';
+import { EventProxy } from './types';
+export declare const proxyEvents: <TPlugin extends BasePlugin>(client: BotSpecificClient<TPlugin> | client.Client, props: PluginRuntimeProps<TPlugin>) => EventProxy<TPlugin>;

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

@@ -0,0 +1,19 @@
+import type * as client from '@holocronlab/botruntime-client';
+import type { AsyncCollection } from '../../utils/api-paging-utils';
+import type * as utils from '../../utils/type-utils';
+import type { BasePlugin } from '../common';
+export type EventSchedule = NonNullable<client.ClientInputs['createEvent']['schedule']>;
+export type EventSender<TPayload> = {
+    emit: (event: TPayload) => Promise<client.Event>;
+    schedule: (event: TPayload, schedule: EventSchedule) => Promise<client.Event>;
+    withConversationId: (conversationId: string) => EventSender<TPayload>;
+    withUserId: (userId: string) => EventSender<TPayload>;
+    withMessageId: (messageId: string) => EventSender<TPayload>;
+    list: (props?: Omit<client.ClientInputs['listEvents'], 'type' | 'nextToken' | 'conversationId' | 'messageId' | 'userId'>) => AsyncCollection<client.Event>;
+    getById: (props: {
+        id: string;
+    }) => Promise<client.Event>;
+};
+export type EventProxy<TPlugin extends BasePlugin> = utils.Normalize<{
+    [TEventName in keyof TPlugin['events']]: EventSender<TPlugin['events'][TEventName]>;
+}>;

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

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

package/dist/plugin/implementation.d.ts

@@ -0,0 +1,71 @@
+import type { MessageHandlersMap as BotMessageHandlersMap, EventHandlersMap as BotEventHandlersMap, StateExpiredHandlersMap as BotStateExpiredHandlersMap, HookHandlersMap as BotHookHandlersMap, WorkflowHandlersMap as BotWorkflowHandlersMap, ActionHandlersMap as BotActionHandlersMap, BotHandlers } from '../bot';
+import * as utils from '../utils';
+import { BasePlugin, PluginRuntimeProps } from './common';
+import { ActionHandlers, MessageHandlers, EventHandlers, StateExpiredHandlers, HookHandlers, WorkflowHandlers, HookHandlersMap, WorkflowHandlersMap } from './server/types';
+export type PluginImplementationProps<TPlugin extends BasePlugin = BasePlugin> = {
+    actions: ActionHandlers<TPlugin>;
+};
+export declare class PluginImplementation<TPlugin extends BasePlugin = BasePlugin> implements BotHandlers<TPlugin> {
+    readonly props: PluginImplementationProps<TPlugin>;
+    private _runtimeProps;
+    private _actionHandlers;
+    private _messageHandlers;
+    private _eventHandlers;
+    private _stateExpiredHandlers;
+    private _hookHandlers;
+    private _workflowHandlers;
+    private _registerOrder;
+    constructor(props: PluginImplementationProps<TPlugin>);
+    initialize(props: PluginRuntimeProps<TPlugin>): this;
+    private get _runtime();
+    private _getTools;
+    get actionHandlers(): BotActionHandlersMap<TPlugin>;
+    get messageHandlers(): BotMessageHandlersMap<TPlugin>;
+    get eventHandlers(): BotEventHandlersMap<TPlugin>;
+    get stateExpiredHandlers(): BotStateExpiredHandlersMap<TPlugin>;
+    get hookHandlers(): BotHookHandlersMap<TPlugin>;
+    get workflowHandlers(): BotWorkflowHandlersMap<TPlugin>;
+    readonly on: {
+        message: <T extends utils.types.StringKeys<MessageHandlers<TPlugin>>>(type: T, handler: MessageHandlers<TPlugin>[T]) => void;
+        event: <T extends utils.types.StringKeys<EventHandlers<TPlugin>>>(type: T, handler: EventHandlers<TPlugin>[T]) => void;
+        stateExpired: <T extends utils.types.StringKeys<StateExpiredHandlers<TPlugin>>>(type: T, handler: StateExpiredHandlers<TPlugin>[T]) => void;
+        beforeIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_incoming_event"]>>(type: T, handler: HookHandlers<TPlugin>["before_incoming_event"][T]) => void;
+        beforeIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_incoming_message"]>>(type: T, handler: HookHandlers<TPlugin>["before_incoming_message"][T]) => void;
+        beforeOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_outgoing_message"]>>(type: T, handler: HookHandlers<TPlugin>["before_outgoing_message"][T]) => void;
+        beforeOutgoingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_outgoing_call_action"]>>(type: T, handler: HookHandlers<TPlugin>["before_outgoing_call_action"][T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        beforeIncomingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["before_incoming_call_action"]>>(type: T, handler: HookHandlers<TPlugin>["before_incoming_call_action"][T]) => void;
+        afterIncomingEvent: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["after_incoming_event"]>>(type: T, handler: HookHandlers<TPlugin>["after_incoming_event"][T]) => void;
+        afterIncomingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["after_incoming_message"]>>(type: T, handler: HookHandlers<TPlugin>["after_incoming_message"][T]) => void;
+        afterOutgoingMessage: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["after_outgoing_message"]>>(type: T, handler: HookHandlers<TPlugin>["after_outgoing_message"][T]) => void;
+        afterOutgoingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["after_outgoing_call_action"]>>(type: T, handler: HookHandlers<TPlugin>["after_outgoing_call_action"][T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        afterIncomingCallAction: <T extends utils.types.StringKeys<HookHandlersMap<TPlugin>["after_incoming_call_action"]>>(type: T, handler: HookHandlers<TPlugin>["after_incoming_call_action"][T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowStart: <T extends utils.types.StringKeys<WorkflowHandlersMap<TPlugin>["started"]>>(type: T, handler: WorkflowHandlers<TPlugin>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowContinue: <T extends utils.types.StringKeys<WorkflowHandlersMap<TPlugin>["continued"]>>(type: T, handler: WorkflowHandlers<TPlugin>[T]) => void;
+        /**
+         * # EXPERIMENTAL
+         * This API is experimental and may change in the future.
+         */
+        workflowTimeout: <T extends utils.types.StringKeys<WorkflowHandlersMap<TPlugin>["timed_out"]>>(type: T, handler: WorkflowHandlers<TPlugin>[T]) => void;
+    };
+    /**
+     * checks if the actual event resolves to the target event
+     */
+    private _eventResolvesTo;
+    private _stripAliasPrefix;
+}

package/dist/plugin/implementation.test.d.ts

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

package/dist/plugin/index.d.ts

@@ -0,0 +1,4 @@
+export * from './definition';
+export * from './implementation';
+export * from './server';
+export * from './common';

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

@@ -0,0 +1,2 @@
+export { proxyMessage, proxyMessages } from './proxy';
+export { ActionableMessage, MessageFinder } from './types';

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

@@ -0,0 +1,13 @@
+import type * as client from '@holocronlab/botruntime-client';
+import type { BotSpecificClient } from '../../bot';
+import type { BasePlugin, PluginRuntimeProps } from '../common';
+import type { ActionableMessage, AnyPluginMessage, MessageFinder } from './types';
+export declare const proxyMessages: <TPlugin extends BasePlugin>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+}) => MessageFinder<TPlugin>;
+export declare const proxyMessage: <TPlugin extends BasePlugin, TMessage extends client.Message | AnyPluginMessage<TPlugin> = AnyPluginMessage<TPlugin>>(props: {
+    client: BotSpecificClient<TPlugin> | client.Client;
+    plugin?: PluginRuntimeProps<TPlugin>;
+    message: TMessage;
+}) => ActionableMessage<TPlugin, TMessage>;

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

@@ -0,0 +1,22 @@
+import type * as client from '@holocronlab/botruntime-client';
+import type { GetMessages } from '../../bot';
+import type { commonTypes } from '../../common';
+import type { AsyncCollection } from '../../utils/api-paging-utils';
+import type * as typeUtils from '../../utils/type-utils';
+import type { BasePlugin } from '../common';
+import type { IncomingMessages } from '../server';
+export type MessageFinder<TPlugin extends BasePlugin> = {
+    list: (props?: Omit<client.ClientInputs['listMessages'], 'nextToken'>) => AsyncCollection<ActionableMessage<TPlugin>>;
+    getById: (props: {
+        id: string;
+    }) => Promise<ActionableMessage<TPlugin>>;
+};
+export type AnyPluginMessage<TPlugin extends BasePlugin> = IncomingMessages<TPlugin>['*'] | IncomingMessages<TPlugin>[typeUtils.StringKeys<GetMessages<TPlugin>>];
+export type ActionableMessage<TPlugin extends BasePlugin, TMessage extends client.Message | AnyPluginMessage<TPlugin> = client.Message> = typeUtils.Merge<TMessage, {
+    tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['conversation']['tags']>>;
+}> & {
+    delete: () => Promise<void>;
+    update: (props: typeUtils.Merge<Omit<client.ClientInputs['updateMessage'], 'id'>, {
+        tags: commonTypes.ToTags<typeUtils.StringKeys<TPlugin['message']['tags']>>;
+    }>) => Promise<ActionableMessage<TPlugin, TMessage>>;
+};

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

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