@botpress/sdk 2.0.4 → 2.1.0

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

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

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

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

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

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

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

@@ -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 './integration-logger';
+export declare const integrationHandler: (instance: IntegrationHandlers<BaseIntegration>) => (req: Request) => Promise<Response | void>;

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

@@ -0,0 +1,16 @@
+import { BaseLogger } from '../../base-logger';
+type IntegrationLogOptions = {
+    userID?: string;
+    conversationID?: string;
+    visibleToBotOwners?: boolean;
+};
+export declare class IntegrationLogger extends BaseLogger<IntegrationLogOptions> {
+    constructor(options?: IntegrationLogOptions);
+    with(options: IntegrationLogOptions): IntegrationLogger;
+    withUserID(userID: string): IntegrationLogger;
+    withConversationID(conversationID: string): IntegrationLogger;
+    withVisibleToBotOwners(visibleToBotOwners: boolean): IntegrationLogger;
+    forBot(): IntegrationLogger;
+    protected getJsonMessage(msg: string): string;
+}
+export {};

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 { type IntegrationLogger } from './integration-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,52 @@
+import * as utils from '../../utils/type-utils';
+export type BaseMessage = {
+    tags: Record<string, any>;
+};
+export type BaseConversation = {
+    tags: Record<string, any>;
+};
+export type BaseChannel = {
+    messages: Record<string, any>;
+    message: BaseMessage;
+    conversation: BaseConversation;
+};
+export type BaseUser = {
+    tags: Record<string, any>;
+};
+export type BaseAction = {
+    input: any;
+    output: any;
+};
+export type BaseIntegration = {
+    name: string;
+    version: string;
+    configuration: any;
+    configurations: Record<string, any>;
+    actions: Record<string, BaseAction>;
+    channels: Record<string, BaseChannel>;
+    events: Record<string, any>;
+    states: Record<string, any>;
+    user: BaseUser;
+    entities: Record<string, any>;
+};
+export type InputBaseChannel = utils.DeepPartial<BaseChannel>;
+export type DefaultChannel<C extends InputBaseChannel> = {
+    messages: utils.Default<C['messages'], BaseChannel['messages']>;
+    message: utils.Default<C['message'], BaseChannel['message']>;
+    conversation: utils.Default<C['conversation'], BaseChannel['conversation']>;
+};
+export type InputBaseIntegration = utils.DeepPartial<BaseIntegration>;
+export type DefaultIntegration<I extends InputBaseIntegration> = {
+    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']>;
+    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']>;
+    channels: undefined extends I['channels'] ? BaseIntegration['channels'] : {
+        [K in keyof I['channels']]: DefaultChannel<utils.Cast<I['channels'][K], InputBaseChannel>>;
+    };
+};

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

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

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

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

package/dist/interface/definition.d.ts

@@ -0,0 +1,70 @@
+import { ActionDefinition, ChannelDefinition, EntityDefinition, EventDefinition } from '../integration/definition';
+import { ZuiObjectSchema, GenericZuiSchema, ZodRef } from '../zui';
+type BaseEvents = Record<string, ZuiObjectSchema>;
+type BaseActions = Record<string, ZuiObjectSchema>;
+type BaseMessages = Record<string, ZuiObjectSchema>;
+type BaseChannels = Record<string, BaseMessages>;
+type BaseEntities = Record<string, ZuiObjectSchema>;
+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 GenericChannelDefinition<TEntities extends BaseEntities, TChannel extends BaseChannels[string] = BaseChannels[string]> = {
+    messages: {
+        [K in keyof TChannel]: {
+            schema: GenericZuiSchema<EntityReferences<TEntities>, TChannel[K]>;
+        };
+    };
+};
+type GenericActionDefinition<TEntities extends BaseEntities, TAction extends BaseActions[string] = BaseActions[string]> = {
+    title?: string;
+    description?: string;
+    billable?: boolean;
+    cacheable?: boolean;
+    input: {
+        schema: GenericZuiSchema<EntityReferences<TEntities>, TAction>;
+    };
+    output: {
+        schema: GenericZuiSchema<EntityReferences<TEntities>, ZuiObjectSchema>;
+    };
+};
+export type InterfaceDefinitionProps<TName extends string = string, TVersion extends string = string, TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEntities = BaseEntities, TChannels extends BaseChannels = BaseChannels> = {
+    name: TName;
+    version: TVersion;
+    entities?: {
+        [K in keyof TEntities]: EntityDefinition<TEntities[K]>;
+    };
+    events?: {
+        [K in keyof TEvents]: GenericEventDefinition<TEntities, TEvents[K]>;
+    };
+    actions?: {
+        [K in keyof TActions]: GenericActionDefinition<TEntities, TActions[K]>;
+    };
+    channels?: {
+        [K in keyof TChannels]: GenericChannelDefinition<TEntities, TChannels[K]>;
+    };
+    templateName?: string;
+};
+export declare class InterfaceDefinition<TName extends string = string, TVersion extends string = string, TEntities extends BaseEntities = BaseEntities, TActions extends BaseActions = BaseActions, TEvents extends BaseEvents = BaseEvents, TChannels extends BaseChannels = BaseChannels> {
+    readonly props: InterfaceDefinitionProps<TName, TVersion, TEntities, TActions, TEvents, TChannels>;
+    readonly name: this['props']['name'];
+    readonly version: this['props']['version'];
+    readonly entities: {
+        [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: InterfaceDefinitionProps<TName, TVersion, TEntities, TActions, TEvents, TChannels>);
+    private _getEntityReference;
+}
+export {};

package/dist/interface/index.d.ts

@@ -0,0 +1 @@
+export * from './definition';

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

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

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

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

package/dist/log.d.ts

@@ -0,0 +1,7 @@
+export type Logger = {
+    debug(message: string, metadata?: any): void;
+    info(message: string, metadata?: any): void;
+    warn(message: string, metadata?: any): void;
+    error(message: string, metadata?: any): void;
+};
+export declare const log: Logger;