@botpress/sdk 0.8.29 → 0.8.31

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

@@ -0,0 +1,60 @@
+import { AnyZodObject, GenericZuiSchema, ZodRef } from '../../zui';
+import { BaseActions, BaseEntities, BaseEvents } from './generic';
+import { EntityDefinition, InterfaceImplementationStatement, ResolvedInterface } from './types';
+type EntityReferences<TEntities extends BaseEntities> = {
+    [K in keyof TEntities]: ZodRef;
+};
+type GenericEventDefinition<TEntities extends BaseEntities, TEvent extends BaseEvents[string] = BaseEvents[string]> = {
+    schema: GenericZuiSchema<EntityReferences<TEntities>, TEvent>;
+};
+type GenericActionDefinition<TEntities extends BaseEntities, TAction extends BaseActions[string] = BaseActions[string]> = {
+    input: {
+        schema: GenericZuiSchema<EntityReferences<TEntities>, TAction>;
+    };
+    output: {
+        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> = {
+    name: string;
+    version: string;
+    events: {
+        [K in keyof TEvents]: GenericEventDefinition<TEntities, TEvents[K]>;
+    };
+    actions: {
+        [K in keyof TActions]: GenericActionDefinition<TEntities, TActions[K]>;
+    };
+    entities: {
+        [K in keyof TEntities]: EntityDefinition<TEntities[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;
+};
+export declare class InterfaceDeclaration<TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents> {
+    readonly props: InterfaceDeclarationProps<TEntities, TActions, TEvents>;
+    readonly name: this['props']['name'];
+    readonly version: this['props']['version'];
+    readonly entities: this['props']['entities'];
+    readonly events: this['props']['events'];
+    readonly actions: this['props']['actions'];
+    readonly templateName: this['props']['templateName'];
+    constructor(props: InterfaceDeclarationProps<TEntities, TActions, TEvents>);
+    resolve(props: InterfaceResolveInput<TEntities>): InterfaceResolveOutput<TActions, TEvents>;
+    private _dereference;
+    private _rename;
+}
+export {};

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

@@ -0,0 +1,86 @@
+import { SchemaDefinition } from '../../schema';
+import { AnyZodObject } from '../../type-utils';
+import { BaseConfig, BaseEvents, BaseActions, BaseMessages, BaseChannels, BaseStates, BaseEntities } from './generic';
+export type TagDefinition = {
+    title?: string;
+    description?: string;
+};
+export type ConfigurationDefinition<TConfig extends BaseConfig = BaseConfig> = SchemaDefinition<TConfig> & {
+    identifier?: {
+        required?: boolean;
+        linkTemplateScript?: string;
+    };
+};
+export type EventDefinition<TEvent extends BaseEvents[string] = BaseEvents[string]> = SchemaDefinition<TEvent> & {
+    title?: string;
+    description?: string;
+};
+export type MessageDefinition<TMessage extends BaseMessages[string] = BaseMessages[string]> = SchemaDefinition<TMessage>;
+export type ChannelDefinition<TChannel extends BaseChannels[string] = BaseChannels[string]> = {
+    title?: string;
+    description?: string;
+    messages: {
+        [K in keyof TChannel]: MessageDefinition<TChannel[K]>;
+    };
+    message?: {
+        tags?: Record<string, TagDefinition>;
+    };
+    conversation?: Partial<{
+        tags: Record<string, TagDefinition>;
+        /**
+         * @deprecated
+         */
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    }>;
+};
+export type ActionDefinition<TAction extends BaseActions[string] = BaseActions[string]> = {
+    title?: string;
+    description?: string;
+    input: SchemaDefinition<TAction>;
+    output: SchemaDefinition<AnyZodObject>;
+};
+export type StateDefinition<TState extends BaseStates[string] = BaseStates[string]> = SchemaDefinition<TState> & {
+    type: 'integration' | 'conversation' | 'user';
+};
+export type UserDefinition = Partial<{
+    tags: Record<string, TagDefinition>;
+    /**
+     * @deprecated
+     */
+    creation: {
+        enabled: boolean;
+        requiredTags: string[];
+    };
+}>;
+export type SecretDefinition = {
+    optional?: boolean;
+    description?: string;
+};
+export type EntityDefinition<TEntity extends BaseEntities[string] = BaseEntities[string]> = SchemaDefinition<TEntity> & {
+    title?: string;
+    description?: string;
+};
+export type ResolvedInterface<TEvents extends BaseEvents = BaseEvents, TActions extends BaseActions = BaseActions> = {
+    actions: {
+        [K in keyof TActions]: ActionDefinition<TActions[K]>;
+    };
+    events: {
+        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
+    };
+};
+export type InterfaceImplementationStatement = {
+    name: string;
+    version: string;
+    entities: Record<string, {
+        name: string;
+    }>;
+    actions: Record<string, {
+        name: string;
+    }>;
+    events: Record<string, {
+        name: string;
+    }>;
+};

package/dist/integration/generic.d.ts

@@ -25,4 +25,5 @@ export type BaseIntegration = {
             requiredTags: string[];
         };
     };
+    entities: Record<string, any>;
 };

package/dist/interfaces/hitl.d.ts

@@ -0,0 +1,10 @@
+import { InterfaceDeclaration } from '../integration/definition';
+export declare const hitl: InterfaceDeclaration<import("../integration/definition/generic").BaseEntities, {
+    startHITL: import("@bpinternal/zui").ZodObject<{
+        upstreamConversationId: import("@bpinternal/zui").ZodString;
+    }, "strip", import("@bpinternal/zui").ZodTypeAny, {
+        upstreamConversationId: string;
+    }, {
+        upstreamConversationId: string;
+    }>;
+}, import("../integration/definition/generic").BaseEvents>;

package/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './llm';
+export * from './hitl';
+export * from './sync';