@botpress/sdk 2.0.3 → 2.0.4

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

@@ -1,47 +0,0 @@
-import * as client from '@botpress/client';
-import * as common from '../types';
-import * as types from './types';
-export * from './types';
-/**
- * Just like the regular botpress client, but typed with the integration's properties.
- */
-export declare class IntegrationSpecificClient<TIntegration extends common.BaseIntegration> implements types.ClientOperations<TIntegration> {
-    private readonly _client;
-    constructor(_client: client.Client);
-    createConversation: types.CreateConversation<TIntegration>;
-    getConversation: types.GetConversation<TIntegration>;
-    listConversations: types.ListConversations<TIntegration>;
-    getOrCreateConversation: types.GetOrCreateConversation<TIntegration>;
-    updateConversation: types.UpdateConversation<TIntegration>;
-    deleteConversation: types.DeleteConversation<TIntegration>;
-    listParticipants: types.ListParticipants<TIntegration>;
-    addParticipant: types.AddParticipant<TIntegration>;
-    getParticipant: types.GetParticipant<TIntegration>;
-    removeParticipant: types.RemoveParticipant<TIntegration>;
-    createEvent: types.CreateEvent<TIntegration>;
-    getEvent: types.GetEvent<TIntegration>;
-    listEvents: types.ListEvents<TIntegration>;
-    createMessage: types.CreateMessage<TIntegration>;
-    getOrCreateMessage: types.GetOrCreateMessage<TIntegration>;
-    getMessage: types.GetMessage<TIntegration>;
-    updateMessage: types.UpdateMessage<TIntegration>;
-    listMessages: types.ListMessages<TIntegration>;
-    deleteMessage: types.DeleteMessage<TIntegration>;
-    createUser: types.CreateUser<TIntegration>;
-    getUser: types.GetUser<TIntegration>;
-    listUsers: types.ListUsers<TIntegration>;
-    getOrCreateUser: types.GetOrCreateUser<TIntegration>;
-    updateUser: types.UpdateUser<TIntegration>;
-    deleteUser: types.DeleteUser<TIntegration>;
-    getState: types.GetState<TIntegration>;
-    setState: types.SetState<TIntegration>;
-    getOrSetState: types.GetOrSetState<TIntegration>;
-    patchState: types.PatchState<TIntegration>;
-    configureIntegration: types.ConfigureIntegration<TIntegration>;
-    uploadFile: types.UploadFile<TIntegration>;
-    upsertFile: types.UpsertFile<TIntegration>;
-    deleteFile: types.DeleteFile<TIntegration>;
-    listFiles: types.ListFiles<TIntegration>;
-    getFile: types.GetFile<TIntegration>;
-    updateFileMetadata: types.UpdateFileMetadata<TIntegration>;
-}

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

@@ -1,177 +0,0 @@
-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 their name as prefix for event types or tags.
- */
-type WithRequiredPrefix<TTags extends string, TPrefix extends string> = string extends TTags ? string : utils.Join<[TPrefix, ':', TTags]>;
-/**
- * @deprecated Integration's should no longer use their name as prefix for event types or tags.
- */
-type WithOptionalPrefix<TTags extends string, TPrefix extends string> = TTags | WithRequiredPrefix<TTags, TPrefix>;
-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: WithRequiredPrefix<utils.Cast<TEvent, string>, TIntegration['name']>;
-        payload: TIntegration['events'][TEvent];
-    }>;
-};
-export type CreateEvent<TIntegration extends common.BaseIntegration> = <TEvent extends keyof TIntegration['events']>(x: utils.Merge<Arg<client.Client['createEvent']>, {
-    type: WithOptionalPrefix<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?: WithRequiredPrefix<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'], {
-        type: utils.Cast<TMessage, string>;
-        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 type ClientOperations<TIntegration extends common.BaseIntegration> = {
-    createConversation: CreateConversation<TIntegration>;
-    getConversation: GetConversation<TIntegration>;
-    listConversations: ListConversations<TIntegration>;
-    getOrCreateConversation: GetOrCreateConversation<TIntegration>;
-    updateConversation: UpdateConversation<TIntegration>;
-    deleteConversation: DeleteConversation<TIntegration>;
-    listParticipants: ListParticipants<TIntegration>;
-    addParticipant: AddParticipant<TIntegration>;
-    getParticipant: GetParticipant<TIntegration>;
-    removeParticipant: RemoveParticipant<TIntegration>;
-    createEvent: CreateEvent<TIntegration>;
-    getEvent: GetEvent<TIntegration>;
-    listEvents: ListEvents<TIntegration>;
-    createMessage: CreateMessage<TIntegration>;
-    getOrCreateMessage: GetOrCreateMessage<TIntegration>;
-    getMessage: GetMessage<TIntegration>;
-    updateMessage: UpdateMessage<TIntegration>;
-    listMessages: ListMessages<TIntegration>;
-    deleteMessage: DeleteMessage<TIntegration>;
-    createUser: CreateUser<TIntegration>;
-    getUser: GetUser<TIntegration>;
-    listUsers: ListUsers<TIntegration>;
-    getOrCreateUser: GetOrCreateUser<TIntegration>;
-    updateUser: UpdateUser<TIntegration>;
-    deleteUser: DeleteUser<TIntegration>;
-    getState: GetState<TIntegration>;
-    setState: SetState<TIntegration>;
-    getOrSetState: GetOrSetState<TIntegration>;
-    patchState: PatchState<TIntegration>;
-    configureIntegration: ConfigureIntegration<TIntegration>;
-    uploadFile: UploadFile<TIntegration>;
-    upsertFile: UpsertFile<TIntegration>;
-    deleteFile: DeleteFile<TIntegration>;
-    listFiles: ListFiles<TIntegration>;
-    getFile: GetFile<TIntegration>;
-    updateFileMetadata: UpdateFileMetadata<TIntegration>;
-};
-export type ClientInputs<TIntegration extends common.BaseIntegration> = {
-    [K in keyof ClientOperations<TIntegration>]: Arg<ClientOperations<TIntegration>[K]>;
-};
-export type ClientOutputs<TIntegration extends common.BaseIntegration> = {
-    [K in keyof ClientOperations<TIntegration>]: Awaited<Res<ClientOperations<TIntegration>[K]>>;
-};
-export {};

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

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

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

@@ -1,21 +0,0 @@
-import { z } from '../../zui';
-declare const schemaName: unique symbol;
-type BaseSchemas = Record<string, z.ZodSchema>;
-export type SchemaStoreProps<TSchemas extends BaseSchemas = BaseSchemas> = {
-    [K in keyof TSchemas]: {
-        schema: TSchemas[K];
-    };
-};
-export type BrandedSchema<TSchema extends BaseSchemas[string] = BaseSchemas[string]> = {
-    schema: TSchema;
-    [schemaName]: string;
-};
-export type SchemaStore<TSchemas extends BaseSchemas = BaseSchemas> = {
-    [K in keyof TSchemas]: BrandedSchema<TSchemas[K]>;
-};
-export declare const createStore: <TSchemas extends BaseSchemas>(props: SchemaStoreProps<TSchemas> | undefined) => SchemaStore<TSchemas>;
-export declare const isBranded: (schema: BrandedSchema | {
-    schema: z.ZodSchema;
-}) => schema is BrandedSchema;
-export declare const getName: (schema: BrandedSchema) => string;
-export {};

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

@@ -1,9 +0,0 @@
-import { ZuiObjectSchema } from '../../zui';
-export type BaseConfig = ZuiObjectSchema;
-export type BaseConfigs = Record<string, BaseConfig>;
-export type BaseEvents = Record<string, ZuiObjectSchema>;
-export type BaseActions = Record<string, ZuiObjectSchema>;
-export type BaseMessages = Record<string, ZuiObjectSchema>;
-export type BaseChannels = Record<string, BaseMessages>;
-export type BaseStates = Record<string, ZuiObjectSchema>;
-export type BaseEntities = Record<string, ZuiObjectSchema>;

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

@@ -1,76 +0,0 @@
-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 { ConfigurationDefinition, EventDefinition, ChannelDefinition, ActionDefinition, StateDefinition, UserDefinition, SecretDefinition, EntityDefinition, AdditionalConfigurationDefinition } 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;
-    title?: string;
-    description?: string;
-    icon?: string;
-    readme?: string;
-    identifier?: {
-        extractScript?: string;
-        fallbackHandlerScript?: string;
-    };
-    configuration?: ConfigurationDefinition<TConfig>;
-    configurations?: {
-        [K in keyof TConfigs]: AdditionalConfigurationDefinition<TConfigs[K]>;
-    };
-    events?: {
-        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
-    };
-    actions?: {
-        [K in keyof TActions]: ActionDefinition<TActions[K]>;
-    };
-    channels?: {
-        [K in keyof TChannels]: ChannelDefinition<TChannels[K]>;
-    };
-    states?: {
-        [K in keyof TStates]: StateDefinition<TStates[K]>;
-    };
-    user?: UserDefinition;
-    secrets?: Record<string, SecretDefinition>;
-    entities?: {
-        [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
-    };
-    interfaces?: Record<string, InterfaceExtension>;
-};
-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 ExtensionBuilder<TIntegrationEntities extends BaseEntities, TInterfaceEntities extends BaseEntities> = (input: ExtensionBuilderInput<TIntegrationEntities>) => ExtensionBuilderOutput<TInterfaceEntities>;
-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'];
-    readonly version: this['props']['version'];
-    readonly title: this['props']['title'];
-    readonly description: this['props']['description'];
-    readonly icon: this['props']['icon'];
-    readonly readme: this['props']['readme'];
-    readonly configuration: this['props']['configuration'];
-    readonly configurations: this['props']['configurations'];
-    readonly events: this['props']['events'];
-    readonly actions: this['props']['actions'];
-    readonly channels: this['props']['channels'];
-    readonly states: this['props']['states'];
-    readonly user: this['props']['user'];
-    readonly secrets: this['props']['secrets'];
-    readonly identifier: this['props']['identifier'];
-    readonly entities: this['props']['entities'];
-    readonly interfaces: this['props']['interfaces'];
-    constructor(props: IntegrationDefinitionProps<TName, TVersion, TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>);
-    extend<P extends InterfacePackage>(interfacePkg: P, builder: ExtensionBuilder<TEntities, EntitiesOfPackage<P>>): this;
-}

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

@@ -1,106 +0,0 @@
-import { SchemaDefinition } from '../../schema';
-import { ZuiObjectSchema } from '../../zui';
-import { BaseConfig, BaseEvents, BaseActions, BaseMessages, BaseChannels, BaseStates, BaseEntities, BaseConfigs } 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 AdditionalConfigurationDefinition<TConfig extends BaseConfigs[string] = BaseConfigs[string]> = ConfigurationDefinition<TConfig> & {
-    title?: string;
-    description?: 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<ZuiObjectSchema>;
-    billable?: boolean;
-    cacheable?: boolean;
-};
-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, TChannels extends BaseChannels = BaseChannels> = {
-    actions: {
-        [K in keyof TActions]: ActionDefinition<TActions[K]>;
-    };
-    events: {
-        [K in keyof TEvents]: EventDefinition<TEvents[K]>;
-    };
-    channels: {
-        [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> = {
-    name: string;
-    version: 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/implementation.d.ts

@@ -1,31 +0,0 @@
-import type { Server } from 'node:http';
-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>;
-    handler: WebhookFunction<TIntegration>;
-    /**
-     * @deprecated
-     */
-    createUser?: CreateUserFunction<TIntegration>;
-    /**
-     * @deprecated
-     */
-    createConversation?: CreateConversationFunction<TIntegration>;
-    actions: ActionFunctions<TIntegration>;
-    channels: ChannelFunctions<TIntegration>;
-};
-export declare class IntegrationImplementation<TIntegration extends BaseIntegration = BaseIntegration> {
-    readonly props: IntegrationImplementationProps<TIntegration>;
-    readonly actions: IntegrationImplementationProps<TIntegration>['actions'];
-    readonly channels: IntegrationImplementationProps<TIntegration>['channels'];
-    readonly register: IntegrationImplementationProps<TIntegration>['register'];
-    readonly unregister: IntegrationImplementationProps<TIntegration>['unregister'];
-    readonly createUser: IntegrationImplementationProps<TIntegration>['createUser'];
-    readonly createConversation: IntegrationImplementationProps<TIntegration>['createConversation'];
-    readonly webhook: IntegrationImplementationProps<TIntegration>['handler'];
-    constructor(props: IntegrationImplementationProps<TIntegration>);
-    readonly handler: (req: import("../serve").Request) => Promise<import("../serve").Response | void>;
-    readonly start: (port?: number) => Promise<Server>;
-}

package/dist/integration/index.d.ts

@@ -1,5 +0,0 @@
-export * from './definition';
-export * from './implementation';
-export * from './client';
-export * from './server';
-export * from './types/generic';

package/dist/integration/server/action-metadata.d.ts

@@ -1,9 +0,0 @@
-export type ActionMetadata = {
-    cost: number;
-};
-export declare class ActionMetadataStore {
-    private _cost;
-    get cost(): number;
-    setCost(cost: number): void;
-    toJSON(): ActionMetadata;
-}

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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-export declare const integrationLogger: {
-    /**
-     * Use this function to log messages that will be displayed to the Bot Owner.
-     */
-    forBot: () => {
-        info: (message?: any, ...optionalParams: any[]) => void;
-        warn: (message?: any, ...optionalParams: any[]) => void;
-        error: (message?: any, ...optionalParams: any[]) => void;
-        debug: (message?: any, ...optionalParams: any[]) => void;
-    };
-};
-export type IntegrationLogger = typeof integrationLogger;

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

@@ -1,102 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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 {};