@botpress/sdk 0.11.8 → 1.0.0

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

@@ -1,8 +1,14 @@
+import { InterfacePackage } from '../../package';
 import { z } from '../../zui';
 import { SchemaStore, BrandedSchema } from './branded-schema';
 import { BaseConfig, BaseEvents, BaseActions, BaseChannels, BaseStates, BaseEntities, BaseConfigs } from './generic';
-import { InterfaceDeclaration } from './interface-declaration';
-import { ConfigurationDefinition, EventDefinition, ChannelDefinition, ActionDefinition, StateDefinition, UserDefinition, SecretDefinition, EntityDefinition, InterfaceImplementationStatement, AdditionalConfigurationDefinition } from './types';
+import { ConfigurationDefinition, EventDefinition, ChannelDefinition, ActionDefinition, StateDefinition, UserDefinition, SecretDefinition, EntityDefinition, AdditionalConfigurationDefinition } from './types';
+export type InterfaceInstance = InterfacePackage & {
+    entities: Record<string, {
+        name: string;
+        schema: z.AnyZodObject;
+    }>;
+};
 export type IntegrationDefinitionProps<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: string;
     version: string;
@@ -35,11 +41,16 @@ export type IntegrationDefinitionProps<TConfig extends BaseConfig = BaseConfig,
     entities?: {
         [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
     };
+    interfaces?: Record<string, InterfaceInstance>;
+};
+type EntitiesOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['entities']]: NonNullable<TPackage['definition']['entities']>[K]['schema'];
 };
-type InterfaceTypeArguments<TInterfaceEntities extends BaseEntities> = {
+type ExtensionBuilderInput<TIntegrationEntities extends BaseEntities> = SchemaStore<TIntegrationEntities>;
+type ExtensionBuilderOutput<TInterfaceEntities extends BaseEntities> = {
     [K in keyof TInterfaceEntities]: BrandedSchema<z.ZodSchema<z.infer<TInterfaceEntities[K]>>>;
 };
-type ExtensionBuilder<TIntegrationEntities extends BaseEntities, TInterfaceEntities extends BaseEntities> = (input: SchemaStore<TIntegrationEntities>) => InterfaceTypeArguments<TInterfaceEntities>;
+type ExtensionBuilder<TIntegrationEntities extends BaseEntities, TInterfaceEntities extends BaseEntities> = (input: ExtensionBuilderInput<TIntegrationEntities>) => ExtensionBuilderOutput<TInterfaceEntities>;
 export declare class IntegrationDefinition<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<TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>;
     readonly name: this['props']['name'];
@@ -58,13 +69,8 @@ export declare class IntegrationDefinition<TConfig extends BaseConfig = BaseConf
     readonly secrets: this['props']['secrets'];
     readonly identifier: this['props']['identifier'];
     readonly entities: this['props']['entities'];
-    readonly interfaces: Record<string, InterfaceImplementationStatement>;
+    readonly interfaces: this['props']['interfaces'];
     constructor(props: IntegrationDefinitionProps<TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>);
-    clone(props: Partial<IntegrationDefinitionProps<TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>>): IntegrationDefinition<TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>;
-    extend<E extends BaseEntities>(interfaceDeclaration: InterfaceDeclaration<E>, builder: ExtensionBuilder<TEntities, E>): this;
-    private _mergeActions;
-    private _mergeEvents;
-    private _mergeChannels;
-    private _mergeMessage;
+    extend<P extends InterfacePackage>(interfacePkg: P, builder: ExtensionBuilder<TEntities, EntitiesOfPackage<P>>): this;
 }
 export {};

package/dist/integration/definition/interface-declaration.d.ts

@@ -1,6 +1,6 @@
 import { AnyZodObject, GenericZuiSchema, ZodRef } from '../../zui';
 import { BaseActions, BaseChannels, BaseEntities, BaseEvents } from './generic';
-import { EntityDefinition, InterfaceImplementationStatement, ResolvedInterface } from './types';
+import { ActionDefinition, ChannelDefinition, EntityDefinition, EventDefinition } from './types';
 type EntityReferences<TEntities extends BaseEntities> = {
     [K in keyof TEntities]: ZodRef;
 };
@@ -24,9 +24,6 @@ type GenericActionDefinition<TEntities extends BaseEntities, TAction extends Bas
         schema: GenericZuiSchema<EntityReferences<TEntities>, AnyZodObject>;
     };
 };
-export type InterfaceTemplateNameProps<TEntities extends BaseEntities = BaseEntities> = {
-    [K in keyof TEntities]: string;
-};
 export type InterfaceDeclarationProps<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEntities = BaseEntities, TChannels extends BaseChannels = BaseChannels> = {
     name: string;
     version: string;
@@ -42,32 +39,26 @@ export type InterfaceDeclarationProps<TEntities extends BaseEntities = BaseEntit
     channels?: {
         [K in keyof TChannels]: GenericChannelDefinition<TEntities, TChannels[K]>;
     };
-    templateName?: (name: string, props: InterfaceTemplateNameProps<TEntities>) => string;
-};
-export type InterfaceResolveInput<TEntities extends BaseEntities = BaseEntities> = {
-    entities: {
-        [K in keyof TEntities]: {
-            name: string;
-            schema: TEntities[K];
-        };
-    };
-};
-export type InterfaceResolveOutput<TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents> = {
-    resolved: ResolvedInterface<TActions, TEvents>;
-    implementStatement: InterfaceImplementationStatement;
+    templateName?: string;
 };
-export declare class InterfaceDeclaration<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents> {
-    readonly props: InterfaceDeclarationProps<TEntities, TActions, TEvents>;
+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>;
     readonly name: this['props']['name'];
     readonly version: this['props']['version'];
-    readonly entities: NonNullable<this['props']['entities']>;
-    readonly events: NonNullable<this['props']['events']>;
-    readonly actions: NonNullable<this['props']['actions']>;
-    readonly channels: NonNullable<this['props']['channels']>;
+    readonly entities: {
+        [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
+    };
+    readonly events: {
+        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+    };
+    readonly actions: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+    readonly channels: {
+        [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
+    };
     readonly templateName: this['props']['templateName'];
-    constructor(props: InterfaceDeclarationProps<TEntities, TActions, TEvents>);
-    resolve(props: InterfaceResolveInput<TEntities>): InterfaceResolveOutput<TActions, TEvents>;
-    private _dereference;
-    private _rename;
+    constructor(props: InterfaceDeclarationProps<TEntities, TActions, TEvents, TChannels>);
+    private _getEntityReference;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { SchemaDefinition } from '../../schema';
-import { AnyZodObject } from '../../type-utils';
+import { AnyZodObject } from '../../zui';
 import { BaseConfig, BaseEvents, BaseActions, BaseMessages, BaseChannels, BaseStates, BaseEntities, BaseConfigs } from './generic';
 export type TagDefinition = {
     title?: string;
@@ -80,16 +80,27 @@ export type ResolvedInterface<TEvents extends BaseEvents = BaseEvents, TActions
         [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
     };
 };
-export type InterfaceImplementationStatement = {
+export type InterfaceImplementationStatement<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents, TChannels extends BaseChannels = BaseChannels> = {
     name: string;
     version: string;
-    entities: Record<string, {
-        name: string;
-    }>;
-    actions: Record<string, {
-        name: string;
-    }>;
-    events: Record<string, {
-        name: string;
-    }>;
+    entities: {
+        [K in keyof TEntities]: {
+            name: string;
+        };
+    };
+    actions: {
+        [K in keyof TActions]: {
+            name: string;
+        };
+    };
+    events: {
+        [K in keyof TEvents]: {
+            name: string;
+        };
+    };
+    channels: {
+        [K in keyof TChannels]: {
+            name: string;
+        };
+    };
 };

package/dist/integration/server.d.ts

@@ -1,6 +1,6 @@
 import { type Conversation, type Message, type User } from '@botpress/client';
 import { Request, Response } from '../serve';
-import { Cast, Merge } from '../type-utils';
+import { Cast, Merge } from '../utils/type-utils';
 import { IntegrationSpecificClient } from './client';
 import { ToTags } from './client/types';
 import { type IntegrationContext } from './context';

package/dist/package.d.ts

@@ -0,0 +1,41 @@
+import * as integration from './integration';
+type PackageReference = {
+    id: string;
+} | {
+    uri?: string;
+};
+type IntegrationPackageDefinition = {
+    name: string;
+    version: string;
+    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, integration.InterfaceInstance>;
+};
+type InterfacePackageDefinition = {
+    name: string;
+    version: string;
+    templateName?: string;
+    entities?: Record<string, integration.EntityDefinition>;
+    events?: Record<string, integration.EventDefinition>;
+    actions?: Record<string, integration.ActionDefinition>;
+    channels?: Record<string, integration.ChannelDefinition>;
+};
+export type IntegrationPackage = PackageReference & {
+    type: 'integration';
+    definition: IntegrationPackageDefinition;
+    implementation?: null;
+};
+export type InterfacePackage = PackageReference & {
+    type: 'interface';
+    definition: InterfacePackageDefinition;
+    implementation?: null;
+};
+export type Package = IntegrationPackage | InterfacePackage;
+export {};

package/dist/schema.d.ts

@@ -1,14 +1,13 @@
-import { AnyZodObject } from './type-utils';
 import type z from './zui';
 type SchemaOptions<T> = {
     title: string;
     examples: T[];
 };
 type IsEmptyObject<T> = keyof T extends never ? true : false;
-type UiDefinition<TSchema extends AnyZodObject = AnyZodObject> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
+type UiDefinition<TSchema extends z.AnyZodObject = z.AnyZodObject> = IsEmptyObject<z.infer<TSchema>> extends true ? Record<string, never> : {
     [K in keyof z.infer<TSchema>]: Partial<SchemaOptions<z.infer<TSchema>[K]>>;
 };
-export type SchemaDefinition<TSchema extends AnyZodObject = AnyZodObject> = {
+export type SchemaDefinition<TSchema extends z.AnyZodObject = z.AnyZodObject> = {
     schema: TSchema;
     /**
      * @deprecated

package/dist/utils/index.d.ts

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

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

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

package/dist/{type-utils.d.ts → utils/type-utils.d.ts}

@@ -1,22 +1,12 @@
-import type z from './zui';
-export type AnyZodObject = z.ZodObject<any>;
+export type ValueOf<T> = T[keyof T];
 export type Merge<A extends object, B extends object> = Omit<A, keyof B> & B;
 export type Cast<T, U> = T extends U ? T : U;
-export type Iof<T extends object> = {
-    [K in keyof T]: T[K];
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
 };
+export type Extends<T, U> = T extends U ? true : false;
+export type IsEqual<T, U> = T extends U ? (U extends T ? true : false) : false;
+export type Expect<T extends true> = T;
 export type Join<S extends (string | number | symbol)[]> = S extends [infer H, ...infer T] ? `${Cast<H, string>}${Join<Cast<T, string[]>>}` : S extends [infer H] ? Cast<H, string> : '';
 export type Split<S extends string | number | symbol, D extends string> = S extends `${infer H}${D}${infer T}` ? [H, ...Split<Cast<T, string>, D>] : [S];
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export type ValueOf<T> = T[keyof T];
-export type Writable<T> = {
-    -readonly [K in keyof T]: T[K];
-};
-export type Inspect<T> = {
-    [K in keyof T]: T[K];
-};
-export type KeyBy<T, Key extends keyof T> = {
-    [TInstance in Cast<T[Key], string>]: Extract<T, {
-        [K in Key]: TInstance;
-    }>;
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "0.11.8",
+  "version": "1.0.0",
   "description": "Botpress SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,15 +14,14 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@bpinternal/zui": "0.10.0",
-    "@botpress/client": "0.33.0"
+    "@botpress/client": "0.33.0",
+    "@bpinternal/zui": "0.12.0"
   },
   "devDependencies": {
     "@types/node": "^18.11.17",
     "esbuild": "^0.16.10",
     "ts-node": "^10.9.1",
     "tsup": "^8.0.2",
-    "type-fest": "^3.4.0",
     "typescript": "^4.9.4"
   }
 }

package/dist/bot/integration-instance.d.ts

@@ -1,9 +0,0 @@
-import { BaseIntegration } from '../integration/generic';
-export type IntegrationInstance<TIntegration extends BaseIntegration> = {
-    id: string | null;
-    enabled?: boolean;
-    configurationType?: string | null;
-    configuration?: Record<string, any>;
-    name: TIntegration['name'];
-    version: TIntegration['version'];
-};

package/dist/interfaces/hitl.d.ts

@@ -1,67 +0,0 @@
-import { InterfaceDeclaration } from '../integration';
-import { AnyZodObject } from '../zui';
-type Tuple<T> = [T, T, ...T[]];
-export declare const hitl: InterfaceDeclaration<import("../integration/definition/generic").BaseEntities, {
-    createUser: import("@bpinternal/zui").ZodObject<{
-        name: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
-        pictureUrl: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
-        email: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
-    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
-        name?: string | undefined;
-        pictureUrl?: string | undefined;
-        email?: string | undefined;
-    }, {
-        name?: string | undefined;
-        pictureUrl?: string | undefined;
-        email?: string | undefined;
-    }>;
-    startHitl: import("@bpinternal/zui").ZodObject<{
-        userId: import("@bpinternal/zui").ZodString;
-        title: import("@bpinternal/zui").ZodString;
-        description: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
-        messageHistory: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodArray<import("@bpinternal/zui").ZodUnion<Tuple<AnyZodObject>>, "many">>;
-    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
-        title: string;
-        userId: string;
-        description?: string | undefined;
-        messageHistory?: {
-            [x: string]: any;
-        }[] | undefined;
-    }, {
-        title: string;
-        userId: string;
-        description?: string | undefined;
-        messageHistory?: {
-            [x: string]: any;
-        }[] | undefined;
-    }>;
-    stopHitl: import("@bpinternal/zui").ZodObject<{
-        conversationId: import("@bpinternal/zui").ZodString;
-        reason: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodEnum<["timeout", "cancel"]>>;
-    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
-        conversationId: string;
-        reason?: "timeout" | "cancel" | undefined;
-    }, {
-        conversationId: string;
-        reason?: "timeout" | "cancel" | undefined;
-    }>;
-}, {
-    hitlAssigned: import("@bpinternal/zui").ZodObject<{
-        conversationId: import("@bpinternal/zui").ZodString;
-        userId: import("@bpinternal/zui").ZodString;
-    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
-        conversationId: string;
-        userId: string;
-    }, {
-        conversationId: string;
-        userId: string;
-    }>;
-    hitlStopped: import("@bpinternal/zui").ZodObject<{
-        conversationId: import("@bpinternal/zui").ZodString;
-    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
-        conversationId: string;
-    }, {
-        conversationId: string;
-    }>;
-}>;
-export {};

package/dist/interfaces/index.d.ts

@@ -1,7 +0,0 @@
-export * as schemas from './schemas';
-export * from './hitl';
-export * from './llm';
-export * from './speech-to-text';
-export * from './sync';
-export * from './text-to-image';
-export * from './typing-indicator';