@botpress/sdk 2.4.3 → 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,15 +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;
@@ -43,15 +39,54 @@ export type IntegrationDefinitionProps<TName extends string = string, TVersion e
         [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
     };
     interfaces?: Record<string, InterfaceExtension>;
+    __advanced?: {
+        esbuild?: Partial<esbuild.BuildOptions>;
+    };
 };
 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'];
@@ -71,6 +106,12 @@ export declare class IntegrationDefinition<TName extends string = string, TVersi
     readonly identifier: this['props']['identifier'];
     readonly entities: this['props']['entities'];
     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';