@botpress/sdk 1.6.3 → 2.0.0

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

@@ -1,5 +1,5 @@
 import { SchemaDefinition } from '../../schema';
-import { AnyZodObject } from '../../zui';
+import { ZuiObjectSchema } from '../../zui';
 import { BaseConfig, BaseEvents, BaseActions, BaseMessages, BaseChannels, BaseStates, BaseEntities, BaseConfigs } from './generic';
 export type TagDefinition = {
     title?: string;
@@ -44,7 +44,7 @@ export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[s
     title?: string;
     description?: string;
     input: SchemaDefinition<TAction>;
-    output: SchemaDefinition<AnyZodObject>;
+    output: SchemaDefinition<ZuiObjectSchema>;
     billable?: boolean;
     cacheable?: boolean;
 };

package/dist/interface/definition.d.ts

@@ -1,10 +1,10 @@
 import { ActionDefinition, ChannelDefinition, EntityDefinition, EventDefinition } from '../integration/definition';
-import { AnyZodObject, GenericZuiSchema, ZodRef } from '../zui';
-type BaseEvents = Record<string, AnyZodObject>;
-type BaseActions = Record<string, AnyZodObject>;
-type BaseMessages = Record<string, AnyZodObject>;
+import { ZuiObjectSchema, GenericZuiSchema, ZodRef } from '../zui';
+type BaseEvents = Record<string, ZuiObjectSchema>;
+type BaseActions = Record<string, ZuiObjectSchema>;
+type BaseMessages = Record<string, ZuiObjectSchema>;
 type BaseChannels = Record<string, BaseMessages>;
-type BaseEntities = Record<string, AnyZodObject>;
+type BaseEntities = Record<string, ZuiObjectSchema>;
 type EntityReferences<TEntities extends BaseEntities> = {
     [K in keyof TEntities]: ZodRef;
 };
@@ -25,12 +25,12 @@ type GenericActionDefinition<TEntities extends BaseEntities, TAction extends Bas
         schema: GenericZuiSchema<EntityReferences<TEntities>, TAction>;
     };
     output: {
-        schema: GenericZuiSchema<EntityReferences<TEntities>, AnyZodObject>;
+        schema: GenericZuiSchema<EntityReferences<TEntities>, ZuiObjectSchema>;
     };
 };
-export type InterfaceDeclarationProps<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEntities = BaseEntities, TChannels extends BaseChannels = BaseChannels> = {
-    name: string;
-    version: string;
+export type InterfaceDefinitionProps<TName extends string = string, TVersion extends string = string, TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEntities = BaseEntities, TChannels extends BaseChannels = BaseChannels> = {
+    name: TName;
+    version: TVersion;
     entities?: {
         [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
     };
@@ -45,8 +45,8 @@ export type InterfaceDeclarationProps<TEntities extends BaseEntities = BaseEntit
     };
     templateName?: string;
 };
-export declare class InterfaceDeclaration<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents, TChannels extends BaseChannels = BaseChannels> {
-    readonly props: InterfaceDeclarationProps<TEntities, TActions, TEvents, TChannels>;
+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>;
     readonly name: this['props']['name'];
     readonly version: this['props']['version'];
     readonly entities: {
@@ -62,7 +62,7 @@ export declare class InterfaceDeclaration<TEntities extends BaseEntities = BaseE
         [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
     };
     readonly templateName: this['props']['templateName'];
-    constructor(props: InterfaceDeclarationProps<TEntities, TActions, TEvents, TChannels>);
+    constructor(props: InterfaceDefinitionProps<TName, TVersion, TEntities, TActions, TEvents, TChannels>);
     private _getEntityReference;
 }
 export {};

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

@@ -0,0 +1,34 @@
+import * as utils from '../../utils/type-utils';
+export type BaseChannel = {
+    messages: Record<string, any>;
+};
+export type BaseUser = {
+    tags: Record<string, any>;
+};
+export type BaseAction = {
+    input: any;
+    output: any;
+};
+export type BaseInterface = {
+    name: string;
+    version: string;
+    actions: Record<string, BaseAction>;
+    channels: Record<string, BaseChannel>;
+    events: Record<string, any>;
+    entities: Record<string, any>;
+};
+export type InputBaseChannel = utils.DeepPartial<BaseChannel>;
+export type DefaultChannel<C extends InputBaseChannel> = {
+    messages: utils.Default<C['messages'], BaseChannel['messages']>;
+};
+export type InputBaseInterface = utils.DeepPartial<BaseInterface>;
+export type DefaultInterface<I extends InputBaseInterface> = {
+    name: utils.Default<I['name'], BaseInterface['name']>;
+    version: utils.Default<I['version'], BaseInterface['version']>;
+    actions: utils.Default<I['actions'], BaseInterface['actions']>;
+    events: utils.Default<I['events'], BaseInterface['events']>;
+    entities: utils.Default<I['entities'], BaseInterface['entities']>;
+    channels: undefined extends I['channels'] ? BaseInterface['channels'] : {
+        [K in keyof I['channels']]: DefaultChannel<utils.Cast<I['channels'][K], InputBaseChannel>>;
+    };
+};

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

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

package/dist/package.d.ts

@@ -1,12 +1,15 @@
+/// <reference types="node" />
 import * as integration from './integration';
-type PackageReference = {
-    id: string;
-} | {
-    uri?: string;
-};
-type IntegrationPackageDefinition = {
+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>;
@@ -16,17 +19,27 @@ type IntegrationPackageDefinition = {
     user?: integration.UserDefinition;
     secrets?: Record<string, integration.SecretDefinition>;
     entities?: Record<string, integration.EntityDefinition>;
-    interfaces?: Record<string, integration.InterfaceInstance>;
+    interfaces?: Record<string, PackageReference>;
 };
-type InterfacePackageDefinition = {
-    name: string;
-    version: string;
+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;
@@ -37,5 +50,10 @@ export type InterfacePackage = PackageReference & {
     definition: InterfacePackageDefinition;
     implementation?: null;
 };
-export type Package = IntegrationPackage | InterfacePackage;
+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>);
+}