@botpress/sdk 1.2.0 → 1.2.2

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

@@ -1,22 +1,128 @@
-import { Cast, Join } 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'];
-export type GetChannelByName<TIntegration extends BaseIntegration, TChannelName extends keyof TIntegration['channels']> = Cast<TIntegration['channels'][TChannelName], ChannelDefinition>;
-export type AsTags<T extends Record<string, string | undefined>> = Cast<T, Record<string, string>>;
-type PrefixConfig = {
-    allowPrefix: string;
-} | {
-    enforcePrefix: string;
-} | null;
-export type WithPrefix<TTags extends string, TPrefix extends PrefixConfig = null> = TPrefix extends {
-    allowPrefix: string;
-} ? TTags | Join<[TPrefix['allowPrefix'], ':', TTags]> : TPrefix extends {
-    enforcePrefix: string;
-} ? Join<[TPrefix['enforcePrefix'], ':', TTags]> : TTags;
-export type ToTags<TTags extends string | number | symbol> = AsTags<Partial<Record<Cast<TTags, string>, string>>>;
+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>;
+/**
+ * @deprecated Integration's should no longer use tag prefixes
+ */
+type WithPrefix<TTags extends string, TPrefix extends string> = TTags | utils.Join<[TPrefix, ':', TTags]>;
+type Arg<F extends (...args: any[]) => any> = Parameters<F>[number];
+type Res<F extends (...args: any[]) => any> = ReturnType<F>;
+type AllChannels<TIntegration extends common.BaseIntegration> = utils.ValueOf<TIntegration['channels']>;
+type ConversationResponse<TIntegration extends common.BaseIntegration, ChannelName extends keyof TIntegration['channels'] = keyof TIntegration['channels']> = {
+    conversation: utils.Merge<Awaited<Res<client.Client['getConversation']>>['conversation'], {
+        channel: ChannelName;
+        tags: common.ToTags<keyof TIntegration['channels'][ChannelName]['conversation']['tags']>;
+    }>;
+};
+export type CreateConversation<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels']>(x: {
+    channel: utils.Cast<ChannelName, string>;
+    tags: common.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
+}) => Promise<ConversationResponse<TIntegration, ChannelName>>;
+export type GetConversation<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getConversation']>) => Promise<ConversationResponse<TIntegration>>;
+export type ListConversations<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels']>(x: utils.Merge<Arg<client.Client['listConversations']>, {
+    channel?: utils.Cast<ChannelName, string>;
+    tags?: common.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
+}>) => Res<client.Client['listConversations']>;
+export type GetOrCreateConversation<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels']>(x: {
+    channel: utils.Cast<ChannelName, string>;
+    tags: common.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
+}) => Promise<ConversationResponse<TIntegration, ChannelName>>;
+export type UpdateConversation<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateConversation']>, {
+    tags: common.ToTags<keyof AllChannels<TIntegration>['conversation']['tags']>;
+}>) => Promise<ConversationResponse<TIntegration>>;
+export type DeleteConversation<_TIntegration extends common.BaseIntegration> = client.Client['deleteConversation'];
+export type ListParticipants<_TIntegration extends common.BaseIntegration> = client.Client['listParticipants'];
+export type AddParticipant<_TIntegration extends common.BaseIntegration> = client.Client['addParticipant'];
+export type GetParticipant<_TIntegration extends common.BaseIntegration> = client.Client['getParticipant'];
+export type RemoveParticipant<_TIntegration extends common.BaseIntegration> = client.Client['removeParticipant'];
+type EventResponse<TIntegration extends common.BaseIntegration, TEvent extends keyof TIntegration['events']> = {
+    event: utils.Merge<Awaited<Res<client.Client['getEvent']>>['event'], {
+        type: TEvent;
+        payload: TIntegration['events'][TEvent];
+    }>;
+};
+export type CreateEvent<TIntegration extends common.BaseIntegration> = <TEvent extends keyof TIntegration['events']>(x: utils.Merge<Arg<client.Client['createEvent']>, {
+    type: WithPrefix<utils.Cast<TEvent, string>, TIntegration['name']>;
+    payload: TIntegration['events'][TEvent];
+}>) => Promise<EventResponse<TIntegration, TEvent>>;
+export type GetEvent<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getEvent']>) => Promise<utils.ValueOf<{
+    [K in keyof TIntegration['events']]: EventResponse<TIntegration, K>;
+}>>;
+export type ListEvents<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['listEvents']>, {
+    type: WithPrefix<utils.Cast<keyof TIntegration['events'], string>, TIntegration['name']>;
+}>) => Res<client.Client['listEvents']>;
+type MessageResponse<TIntegration extends common.BaseIntegration, TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']> = {
+    message: utils.Merge<Awaited<Res<client.Client['createMessage']>>['message'], {
+        payload: TIntegration['channels'][TChannel]['messages'][TMessage];
+        tags: common.ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+    }>;
+};
+export type CreateMessage<TIntegration extends common.BaseIntegration> = <TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']>(x: utils.Merge<Arg<client.Client['createMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload: TIntegration['channels'][TChannel]['messages'][TMessage];
+    tags: common.ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+}>) => Promise<MessageResponse<TIntegration, TChannel, TMessage>>;
+export type GetOrCreateMessage<TIntegration extends common.BaseIntegration> = <TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']>(x: utils.Merge<Arg<client.Client['getOrCreateMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload: TIntegration['channels'][TChannel]['messages'][TMessage];
+    tags: common.ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+}>) => Promise<MessageResponse<TIntegration, TChannel, TMessage>>;
+export type GetMessage<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getMessage']>) => Promise<MessageResponse<TIntegration, keyof TIntegration['channels'], keyof utils.ValueOf<TIntegration['channels']>['messages']>>;
+export type UpdateMessage<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateMessage']>, {
+    tags: common.ToTags<keyof AllChannels<TIntegration>['message']['tags']>;
+}>) => Promise<MessageResponse<TIntegration, keyof TIntegration['channels'], keyof utils.ValueOf<TIntegration['channels']>['messages']>>;
+export type ListMessages<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['listMessages']>, {
+    tags: common.ToTags<keyof AllChannels<TIntegration>['message']['tags']>;
+}>) => Res<client.Client['listMessages']>;
+export type DeleteMessage<_TIntegration extends common.BaseIntegration> = client.Client['deleteMessage'];
+type UserResponse<TIntegration extends common.BaseIntegration> = {
+    user: utils.Merge<Awaited<Res<client.Client['getUser']>>['user'], {
+        tags: common.ToTags<keyof TIntegration['user']['tags']>;
+    }>;
+};
+export type CreateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['createUser']>, {
+    tags: common.ToTags<keyof TIntegration['user']['tags']>;
+}>) => Promise<UserResponse<TIntegration>>;
+export type GetUser<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getUser']>) => Promise<UserResponse<TIntegration>>;
+export type ListUsers<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['listUsers']>, {
+    tags: common.ToTags<keyof TIntegration['user']['tags']>;
+}>) => Res<client.Client['listUsers']>;
+export type GetOrCreateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['getOrCreateUser']>, {
+    tags: common.ToTags<keyof TIntegration['user']['tags']>;
+}>) => Promise<UserResponse<TIntegration>>;
+export type UpdateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateUser']>, {
+    tags: common.ToTags<keyof TIntegration['user']['tags']>;
+}>) => Promise<UserResponse<TIntegration>>;
+export type DeleteUser<_TIntegration extends common.BaseIntegration> = client.Client['deleteUser'];
+type StateResponse<TIntegration extends common.BaseIntegration, TState extends keyof TIntegration['states']> = {
+    state: utils.Merge<Awaited<Res<client.Client['getState']>>['state'], {
+        payload: TIntegration['states'][TState];
+    }>;
+    meta: {
+        cached: boolean;
+    };
+};
+export type GetState<TIntegration extends common.BaseIntegration> = <TState extends keyof TIntegration['states']>(x: utils.Merge<Arg<client.Client['getState']>, {
+    name: utils.Cast<TState, string>;
+}>) => Promise<StateResponse<TIntegration, TState>>;
+export type SetState<TIntegration extends common.BaseIntegration> = <TState extends keyof TIntegration['states']>(x: utils.Merge<Arg<client.Client['setState']>, {
+    name: utils.Cast<TState, string>;
+    payload: TIntegration['states'][TState] | null;
+}>) => Promise<StateResponse<TIntegration, TState>>;
+export type GetOrSetState<TIntegration extends common.BaseIntegration> = <TState extends keyof TIntegration['states']>(x: utils.Merge<Arg<client.Client['getOrSetState']>, {
+    name: utils.Cast<TState, string>;
+    payload: TIntegration['states'][TState];
+}>) => Promise<StateResponse<TIntegration, TState>>;
+export type PatchState<TIntegration extends common.BaseIntegration> = <TState extends keyof TIntegration['states']>(x: utils.Merge<Arg<client.Client['patchState']>, {
+    name: utils.Cast<TState, string>;
+    payload: Partial<TIntegration['states'][TState]>;
+}>) => Promise<StateResponse<TIntegration, TState>>;
+export type ConfigureIntegration<_TIntegration extends common.BaseIntegration> = client.Client['configureIntegration'];
+export type UploadFile<_TIntegration extends common.BaseIntegration> = client.Client['uploadFile'];
+export type UpsertFile<_TIntegration extends common.BaseIntegration> = client.Client['upsertFile'];
+export type DeleteFile<_TIntegration extends common.BaseIntegration> = client.Client['deleteFile'];
+export type ListFiles<_TIntegration extends common.BaseIntegration> = client.Client['listFiles'];
+export type GetFile<_TIntegration extends common.BaseIntegration> = client.Client['getFile'];
+export type UpdateFileMetadata<_TIntegration extends common.BaseIntegration> = client.Client['updateFileMetadata'];
 export {};

package/dist/integration/implementation.d.ts

@@ -1,6 +1,6 @@
 import type { Server } from 'node:http';
-import { BaseIntegration } from './generic';
-import { RegisterFunction, UnregisterFunction, WebhookFunction, CreateUserFunction, CreateConversationFunction, ActionFunctions, ChannelFunctions } from './server';
+import { RegisterHandler as RegisterFunction, UnregisterHandler as UnregisterFunction, WebhookHandler as WebhookFunction, CreateUserHandler as CreateUserFunction, CreateConversationHandler as CreateConversationFunction, ActionHandlers as ActionFunctions, ChannelHandlers as ChannelFunctions } from './server';
+import { BaseIntegration } from './types';
 export type IntegrationImplementationProps<TIntegration extends BaseIntegration = BaseIntegration> = {
     register: RegisterFunction<TIntegration>;
     unregister: UnregisterFunction<TIntegration>;

package/dist/integration/index.d.ts

@@ -1,5 +1,4 @@
-export * from './context';
 export * from './definition';
 export * from './implementation';
 export * from './client';
-export * from './logger';
+export * from './server';

package/dist/integration/server/context.d.ts

@@ -0,0 +1,3 @@
+import { IntegrationContext } from './types';
+export declare const integrationOperationSchema: import("@bpinternal/zui").ZodEnum<["webhook_received", "message_created", "action_triggered", "register", "unregister", "ping", "create_user", "create_conversation"]>;
+export declare const extractContext: (headers: Record<string, string | undefined>) => IntegrationContext;

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

@@ -0,0 +1,6 @@
+import { Request, Response } from '../../serve';
+import { BaseIntegration } from '../types';
+import { IntegrationHandlers } from './types';
+export * from './types';
+export * from './logger';
+export declare const integrationHandler: <TIntegration extends BaseIntegration>(instance: IntegrationHandlers<TIntegration>) => (req: Request) => Promise<Response | void>;

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

@@ -0,0 +1,102 @@
+import { type Conversation, type Message, type User } from '@botpress/client';
+import { Request, Response } from '../../serve';
+import { Cast, Merge, ValueOf } from '../../utils/type-utils';
+import { IntegrationSpecificClient } from '../client';
+import { BaseIntegration, ToTags } from '../types';
+import { IntegrationLogger } from './logger';
+type IntegrationOperation = 'webhook_received' | 'message_created' | 'action_triggered' | 'register' | 'unregister' | 'ping' | 'create_user' | 'create_conversation';
+type IntegrationContextConfig<TIntegration extends BaseIntegration> = {
+    configurationType: null;
+    configuration: TIntegration['configuration'];
+} | ValueOf<{
+    [TConfigType in keyof TIntegration['configurations']]: {
+        configurationType: TConfigType;
+        configuration: TIntegration['configurations'][TConfigType];
+    };
+}>;
+export type IntegrationContext<TIntegration extends BaseIntegration = BaseIntegration> = {
+    botId: string;
+    botUserId: string;
+    integrationId: string;
+    webhookId: string;
+    operation: IntegrationOperation;
+} & IntegrationContextConfig<TIntegration>;
+export type CommonHandlerProps<TIntegration extends BaseIntegration> = {
+    ctx: IntegrationContext<TIntegration>;
+    client: IntegrationSpecificClient<TIntegration>;
+    logger: IntegrationLogger;
+};
+export type RegisterPayload = {
+    webhookUrl: string;
+};
+export type RegisterHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & RegisterPayload;
+export type RegisterHandler<TIntegration extends BaseIntegration> = (props: RegisterHandlerProps<TIntegration>) => Promise<void>;
+export type UnregisterPayload = {
+    webhookUrl: string;
+};
+export type UnregisterHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & UnregisterPayload;
+export type UnregisterHandler<TIntegration extends BaseIntegration> = (props: UnregisterHandlerProps<TIntegration>) => Promise<void>;
+export type WebhookPayload = {
+    req: Request;
+};
+export type WebhookHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & WebhookPayload;
+export type WebhookHandler<TIntegration extends BaseIntegration> = (props: WebhookHandlerProps<TIntegration>) => Promise<Response | void>;
+export type ActionMetadata = {
+    setCost: (cost: number) => void;
+};
+export type ActionPayload<T extends string, I> = {
+    type: T;
+    input: I;
+    metadata: ActionMetadata;
+};
+export type ActionHandlerProps<TIntegration extends BaseIntegration, T extends string, I> = CommonHandlerProps<TIntegration> & ActionPayload<T, I>;
+export type ActionHandlers<TIntegration extends BaseIntegration> = {
+    [ActionType in keyof TIntegration['actions']]: (props: ActionHandlerProps<TIntegration, Cast<ActionType, string>, TIntegration['actions'][ActionType]['input']>) => Promise<TIntegration['actions'][ActionType]['output']>;
+};
+export type CreateUserPayload<TIntegration extends BaseIntegration> = {
+    tags: ToTags<keyof TIntegration['user']['tags']>;
+};
+export type CreateUserHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & CreateUserPayload<TIntegration>;
+export type CreateUserHandler<TIntegration extends BaseIntegration> = (props: CreateUserHandlerProps<TIntegration>) => Promise<Response | void>;
+export type CreateConversationPayload<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'] = keyof TIntegration['channels']> = {
+    channel: TChannel;
+    tags: ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags']>;
+};
+export type CreateConversationHandlerProps<TIntegration extends BaseIntegration> = CommonHandlerProps<TIntegration> & CreateConversationPayload<TIntegration>;
+export type CreateConversationHandler<TIntegration extends BaseIntegration> = (props: CreateConversationHandlerProps<TIntegration>) => Promise<Response | void>;
+export type MessagePayload<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']> = {
+    type: TMessage;
+    payload: TIntegration['channels'][TChannel]['messages'][TMessage];
+    conversation: Merge<Conversation, {
+        channel: TChannel;
+        tags: ToTags<keyof TIntegration['channels'][TChannel]['conversation']['tags']>;
+    }>;
+    message: Merge<Message, {
+        tags: ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+    }>;
+    user: Merge<User, {
+        tags: ToTags<keyof TIntegration['user']['tags']>;
+    }>;
+};
+export type MessageHandlerProps<TIntegration extends BaseIntegration, TChannel extends keyof TIntegration['channels'], TMessage extends keyof TIntegration['channels'][TChannel]['messages']> = CommonHandlerProps<TIntegration> & MessagePayload<TIntegration, TChannel, TMessage> & {
+    ack: (props: {
+        tags: ToTags<keyof TIntegration['channels'][TChannel]['message']['tags']>;
+    }) => Promise<void>;
+};
+export type ChannelHandlers<TIntegration extends BaseIntegration> = {
+    [ChannelName in keyof TIntegration['channels']]: {
+        messages: {
+            [MessageType in keyof TIntegration['channels'][ChannelName]['messages']]: (props: CommonHandlerProps<TIntegration> & MessageHandlerProps<TIntegration, ChannelName, MessageType>) => Promise<void>;
+        };
+    };
+};
+export type IntegrationHandlers<TIntegration extends BaseIntegration> = {
+    register: RegisterHandler<TIntegration>;
+    unregister: UnregisterHandler<TIntegration>;
+    webhook: WebhookHandler<TIntegration>;
+    createUser?: CreateUserHandler<TIntegration>;
+    createConversation?: CreateConversationHandler<TIntegration>;
+    actions: ActionHandlers<TIntegration>;
+    channels: ChannelHandlers<TIntegration>;
+};
+export {};

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

@@ -0,0 +1,11 @@
+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/integration/types/generic.d.ts

@@ -0,0 +1,54 @@
+import * as utils from '../../utils/type-utils';
+export type BaseIntegration = {
+    name: string;
+    version: string;
+    configuration: any;
+    configurations: Record<string, any>;
+    actions: Record<string, Record<'input' | 'output', any>>;
+    channels: Record<string, {
+        messages: Record<string, any>;
+        message: {
+            tags: Record<string, any>;
+        };
+        conversation: {
+            tags: Record<string, any>;
+            creation: {
+                enabled: boolean;
+                requiredTags: string[];
+            };
+        };
+    }>;
+    events: Record<string, any>;
+    states: Record<string, any>;
+    user: {
+        tags: Record<string, any>;
+        creation: {
+            enabled: boolean;
+            requiredTags: string[];
+        };
+    };
+    entities: Record<string, any>;
+};
+/**
+ * Usefull for tests, allows to create a channel with only the properties you want to override
+ */
+export type MakeChannel<C extends Partial<BaseIntegration['channels'][string]>> = {
+    messages: utils.Default<C['messages'], BaseIntegration['channels'][string]['messages']>;
+    message: utils.Default<C['message'], BaseIntegration['channels'][string]['message']>;
+    conversation: utils.Default<C['conversation'], BaseIntegration['channels'][string]['conversation']>;
+};
+/**
+ * Usefull for tests, allows to create an integration with only the properties you want to override
+ */
+export type MakeIntegration<I extends Partial<BaseIntegration>> = {
+    name: utils.Default<I['name'], BaseIntegration['name']>;
+    version: utils.Default<I['version'], BaseIntegration['version']>;
+    configuration: utils.Default<I['configuration'], BaseIntegration['configuration']>;
+    configurations: utils.Default<I['configurations'], BaseIntegration['configurations']>;
+    actions: utils.Default<I['actions'], BaseIntegration['actions']>;
+    channels: utils.Default<I['channels'], BaseIntegration['channels']>;
+    events: utils.Default<I['events'], BaseIntegration['events']>;
+    states: utils.Default<I['states'], BaseIntegration['states']>;
+    user: utils.Default<I['user'], BaseIntegration['user']>;
+    entities: utils.Default<I['entities'], BaseIntegration['entities']>;
+};

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

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

package/dist/message.d.ts

@@ -230,7 +230,7 @@ export declare const defaults: {
     };
     readonly bloc: {
         readonly schema: import("@bpinternal/zui").ZodObject<{
-            items: import("@bpinternal/zui").ZodArray<import("@bpinternal/zui").ZodDiscriminatedUnion<"type", [import("@bpinternal/zui").ZodObject<{
+            items: import("@bpinternal/zui").ZodArray<import("@bpinternal/zui").ZodUnion<[import("@bpinternal/zui").ZodObject<{
                 type: import("@bpinternal/zui").ZodLiteral<"text">;
                 payload: import("@bpinternal/zui").ZodObject<{
                     text: import("@bpinternal/zui").ZodString;

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

@@ -1,12 +1,28 @@
+/// <reference types="node" />
 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 SafeCast<T, U> = [T] extends [never] ? U : Cast<T, U>;
 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 Default<T, U> = undefined extends T ? U : T;
+export type IsExtend<X, Y> = X extends Y ? true : false;
+export type IsEquivalent<X, Y> = IsExtend<X, Y> extends true ? IsExtend<Y, X> : false;
+export type IsIdentical<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type IsEqual<X, Y> = IsIdentical<Normalize<X>, Normalize<Y>>;
+export type AssertExtends<A, _B extends A> = true;
+export type AssertTrue<_T extends true> = true;
+export type AssertAll<_T extends true[]> = true;
 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;
+/**
+ * removes string index signature from Record
+ */
+export type ToSealedRecord<R extends Record<string, any>> = {
+    [K in keyof R as string extends K ? never : K]: R[K];
+};
+export type Normalize<T> = T extends (...args: infer A) => infer R ? (...args: Normalize<A>) => Normalize<R> : T extends Promise<infer R> ? Promise<Normalize<R>> : T extends Buffer ? Buffer : T extends object ? T extends infer O ? {
+    [K in keyof O]: Normalize<O[K]>;
+} : never : T;

package/dist/utils/type-utils.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/sdk",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Botpress SDK",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/bot/client/routes.d.ts

@@ -1,81 +0,0 @@
-import { Client } from '@botpress/client';
-import { Cast, Merge } from '../../utils/type-utils';
-import { BaseBot } from '../generic';
-import * as types from './types';
-type Arg<F extends (...args: any[]) => any> = Parameters<F>[number];
-type Res<F extends (...args: any[]) => any> = ReturnType<F>;
-export type CreateConversation<_TBot extends BaseBot> = Client['createConversation'];
-export type GetConversation<_TBot extends BaseBot> = Client['getConversation'];
-export type ListConversations<_TBot extends BaseBot> = Client['listConversations'];
-export type GetOrCreateConversation<_TBot extends BaseBot> = Client['getOrCreateConversation'];
-export type UpdateConversation<_TBot extends BaseBot> = Client['updateConversation'];
-export type DeleteConversation<_TBot extends BaseBot> = Client['deleteConversation'];
-export type ListParticipants<_TBot extends BaseBot> = Client['listParticipants'];
-export type AddParticipant<_TBot extends BaseBot> = Client['addParticipant'];
-export type GetParticipant<_TBot extends BaseBot> = Client['getParticipant'];
-export type RemoveParticipant<_TBot extends BaseBot> = Client['removeParticipant'];
-export type GetEvent<TBot extends BaseBot> = (x: Arg<Client['getEvent']>) => Promise<types.EventResponse<TBot>>;
-export type ListEvents<_TBot extends BaseBot> = Client['listEvents'];
-export type CreateMessage<TBot extends BaseBot> = <TMessage extends keyof types.GetMessages<TBot>>(x: Merge<Arg<Client['createMessage']>, {
-    type: Cast<TMessage, string>;
-    payload: Cast<types.GetMessages<TBot>[TMessage], Record<string, any>>;
-}>) => Promise<types.MessageResponse<TBot, TMessage>>;
-export type GetOrCreateMessage<TBot extends BaseBot> = <TMessage extends keyof types.GetMessages<TBot>>(x: Merge<Arg<Client['getOrCreateMessage']>, {
-    type: Cast<TMessage, string>;
-    payload: Cast<types.GetMessages<TBot>[TMessage], Record<string, any>>;
-}>) => Promise<types.MessageResponse<TBot, TMessage>>;
-export type GetMessage<TBot extends BaseBot> = (x: Arg<Client['getMessage']>) => Promise<types.MessageResponse<TBot>>;
-export type UpdateMessage<TBot extends BaseBot> = (x: Arg<Client['updateMessage']>) => Promise<types.MessageResponse<TBot>>;
-export type ListMessages<_TBot extends BaseBot> = Client['listMessages'];
-export type DeleteMessage<_TBot extends BaseBot> = Client['deleteMessage'];
-export type CreateUser<_TBot extends BaseBot> = Client['createUser'];
-export type GetUser<_TBot extends BaseBot> = Client['getUser'];
-export type ListUsers<_TBot extends BaseBot> = Client['listUsers'];
-export type GetOrCreateUser<_TBot extends BaseBot> = Client['getOrCreateUser'];
-export type UpdateUser<_TBot extends BaseBot> = Client['updateUser'];
-export type DeleteUser<_TBot extends BaseBot> = Client['deleteUser'];
-export type GetState<TBot extends BaseBot> = <TState extends keyof TBot['states']>(x: Merge<Arg<Client['getState']>, {
-    name: Cast<TState, string>;
-}>) => Promise<{
-    state: Merge<Awaited<Res<Client['getState']>>['state'], {
-        payload: TBot['states'][TState];
-    }>;
-}>;
-export type SetState<TBot extends BaseBot> = <TState extends keyof TBot['states']>(x: Merge<Arg<Client['setState']>, {
-    name: Cast<TState, string>;
-    payload: TBot['states'][TState] | null;
-}>) => Promise<{
-    state: Merge<Awaited<Res<Client['setState']>>['state'], {
-        payload: TBot['states'][TState];
-    }>;
-}>;
-export type GetOrSetState<TBot extends BaseBot> = <TState extends keyof TBot['states']>(x: Merge<Arg<Client['getOrSetState']>, {
-    name: Cast<TState, string>;
-    payload: TBot['states'][TState];
-}>) => Promise<{
-    state: Merge<Awaited<Res<Client['getOrSetState']>>['state'], {
-        payload: TBot['states'][TState];
-    }>;
-}>;
-export type PatchState<TBot extends BaseBot> = <TState extends keyof TBot['states']>(x: Merge<Arg<Client['patchState']>, {
-    name: Cast<TState, string>;
-    payload: Partial<TBot['states'][TState]>;
-}>) => Promise<{
-    state: Merge<Awaited<Res<Client['patchState']>>['state'], {
-        payload: TBot['states'][TState];
-    }>;
-}>;
-export type CallAction<TBot extends BaseBot> = <ActionType extends keyof types.EnumerateActions<TBot>>(x: Merge<Arg<Client['callAction']>, {
-    type: Cast<ActionType, string>;
-    input: Cast<types.EnumerateActions<TBot>[ActionType], types.IntegrationInstanceActionDefinition>['input'];
-}>) => Promise<{
-    output: Cast<types.EnumerateActions<TBot>[ActionType], types.IntegrationInstanceActionDefinition>['output'];
-}>;
-export type UploadFile<_TBot extends BaseBot> = Client['uploadFile'];
-export type UpsertFile<_TBot extends BaseBot> = Client['upsertFile'];
-export type DeleteFile<_TBot extends BaseBot> = Client['deleteFile'];
-export type ListFiles<_TBot extends BaseBot> = Client['listFiles'];
-export type GetFile<_TBot extends BaseBot> = Client['getFile'];
-export type UpdateFileMetadata<_TBot extends BaseBot> = Client['updateFileMetadata'];
-export type SearchFiles<_TBot extends BaseBot> = Client['searchFiles'];
-export {};

package/dist/bot/context.d.ts

@@ -1,12 +0,0 @@
-import { z } from '@bpinternal/zui';
-export declare const botOperationSchema: import("@bpinternal/zui").ZodEnum<["event_received", "register", "unregister", "ping", "action_triggered"]>;
-export type BotOperation = z.infer<typeof botOperationSchema>;
-export type BotContext = {
-    botId: string;
-    type: string;
-    operation: BotOperation;
-    configuration: {
-        payload: string;
-    };
-};
-export declare const extractContext: (headers: Record<string, string | undefined>) => BotContext;

package/dist/bot/generic.d.ts

@@ -1,7 +0,0 @@
-import { BaseIntegration } from '../integration/generic';
-export type BaseIntegrations = Record<string, BaseIntegration>;
-export type BaseBot = {
-    integrations: BaseIntegrations;
-    events: Record<string, any>;
-    states: Record<string, any>;
-};

package/dist/bot/server.d.ts

@@ -1,40 +0,0 @@
-import * as client from '@botpress/client';
-import { Request, Response } from '../serve';
-import { BotSpecificClient } from './client';
-import * as types from './client/types';
-import { BotContext } from './context';
-import { StateType } from './definition';
-import { BaseBot } from './generic';
-type CommonArgs<TBot extends BaseBot> = {
-    ctx: BotContext;
-    client: BotSpecificClient<TBot>;
-};
-type MessagePayload<TBot extends BaseBot> = {
-    user: client.User;
-    conversation: client.Conversation;
-    message: types.MessageResponse<TBot>['message'];
-    event: client.Event;
-    states: {
-        [TState in keyof TBot['states']]: {
-            type: StateType;
-            payload: TBot['states'][TState];
-        };
-    };
-};
-type MessageArgs<TBot extends BaseBot> = CommonArgs<TBot> & MessagePayload<TBot>;
-type EventPayload<TBot extends BaseBot> = types.EventResponse<TBot>;
-type EventArgs<TBot extends BaseBot> = CommonArgs<TBot> & EventPayload<TBot>;
-type StateExpiredPayload = {
-    state: client.State;
-};
-type StateExpiredArgs<TBot extends BaseBot> = CommonArgs<TBot> & StateExpiredPayload;
-export type MessageHandler<TBot extends BaseBot> = (args: MessageArgs<TBot>) => Promise<void>;
-export type EventHandler<TBot extends BaseBot> = (args: EventArgs<TBot>) => Promise<void>;
-export type StateExpiredHandler<TBot extends BaseBot> = (args: StateExpiredArgs<TBot>) => Promise<void>;
-export type BotHandlers<TBot extends BaseBot> = {
-    messageHandlers: MessageHandler<TBot>[];
-    eventHandlers: EventHandler<TBot>[];
-    stateExpiredHandlers: StateExpiredHandler<TBot>[];
-};
-export declare const botHandler: <TBot extends BaseBot>(instance: BotHandlers<TBot>) => (req: Request) => Promise<Response | void>;
-export {};