@holocronlab/botruntime-sdk 6.13.3

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

@@ -0,0 +1,55 @@
+import * as client from '@holocronlab/botruntime-client';
+import * as common from '../common';
+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);
+    /**
+     * Access the underlying Botpress client.
+     * This is useful for operations that are not available in the IntegrationSpecificClient.
+     * You probably shouldn't use this directly if you don't know what you're doing.
+     */
+    get _inner(): 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>;
+    initializeIncomingMessage: types.InitializeIncomingMessage<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>;
+    trackAnalytics: types.TrackAnalytics<TIntegration>;
+}

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

@@ -0,0 +1,27 @@
+import * as utils from '../../utils/type-utils';
+import * as common from '../common';
+export type EnumerateMessages<TIntegration extends common.BaseIntegration> = utils.UnionToIntersection<utils.ValueOf<{
+    [TChannelName in keyof TIntegration['channels']]: {
+        [TMessageName in keyof TIntegration['channels'][TChannelName]['messages']]: {
+            type: TMessageName;
+            tags: {
+                [Tag in keyof TIntegration['channels'][TChannelName]['message']['tags']]?: string;
+            };
+            payload: TIntegration['channels'][TChannelName]['messages'][TMessageName];
+        };
+    };
+}>>;
+export type GetChannelByName<TIntegration extends common.BaseIntegration, TChannelName extends keyof TIntegration['channels']> = utils.Cast<TIntegration['channels'][TChannelName], common.BaseChannel>;
+export type GetMessageByName<TIntegration extends common.BaseIntegration, TMessageName extends keyof EnumerateMessages<TIntegration>> = utils.Cast<EnumerateMessages<TIntegration>[TMessageName], {
+    type: string;
+    tags: Record<string, any>;
+    payload: any;
+}>;
+export type ConversationTags<TIntegration extends common.BaseIntegration> = keyof utils.UnionToIntersection<utils.ValueOf<{
+    [TChannelName in keyof TIntegration['channels']]: TIntegration['channels'][TChannelName]['conversation']['tags'];
+}>>;
+export type MessageTags<TIntegration extends common.BaseIntegration> = keyof utils.UnionToIntersection<utils.ValueOf<{
+    [TChannelName in keyof TIntegration['channels']]: TIntegration['channels'][TChannelName]['message']['tags'];
+}>>;
+export type UserTags<TIntegration extends common.BaseIntegration> = keyof TIntegration['user']['tags'];
+export type TagsOfMessage<TIntegration extends common.BaseIntegration, TMessageName extends keyof EnumerateMessages<TIntegration>> = keyof utils.UnionToIntersection<GetMessageByName<TIntegration, TMessageName>['tags']>;

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

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

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

@@ -0,0 +1,209 @@
+import * as client from '@holocronlab/botruntime-client';
+import type { commonTypes } from '../../common';
+import * as utils from '../../utils/type-utils';
+import * as common from '../common';
+import { EnumerateMessages, ConversationTags, GetChannelByName, GetMessageByName, MessageTags, UserTags } from './sub-types';
+type Arg<F extends (...args: any[]) => any> = Parameters<F>[number];
+type Res<F extends (...args: any[]) => any> = ReturnType<F>;
+type ConversationResponse<TIntegration extends common.BaseIntegration, ChannelName extends keyof TIntegration['channels'] = keyof TIntegration['channels']> = utils.ValueOf<{
+    [TChannelName in ChannelName]: {
+        conversation: utils.Merge<Awaited<Res<client.Client['getConversation']>>['conversation'], {
+            channel: TChannelName;
+            tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannelName]['conversation']['tags']>;
+        }>;
+    };
+}>;
+type GetOrCreateConversationResponse<TIntegration extends common.BaseIntegration, ChannelName extends keyof TIntegration['channels'] = keyof TIntegration['channels']> = utils.ValueOf<{
+    [TChannelName in ChannelName]: utils.Merge<Awaited<Res<client.Client['getOrCreateConversation']>>, {
+        conversation: utils.Merge<Awaited<Res<client.Client['getOrCreateConversation']>>['conversation'], {
+            channel: TChannelName;
+            tags: commonTypes.ToTags<keyof TIntegration['channels'][TChannelName]['conversation']['tags']>;
+        }>;
+    }>;
+}>;
+export type CreateConversation<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels']>(x: {
+    channel: utils.Cast<ChannelName, string>;
+    tags: commonTypes.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?: commonTypes.ToTags<keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>;
+}>) => Res<client.Client['listConversations']>;
+export type GetOrCreateConversation<TIntegration extends common.BaseIntegration> = <ChannelName extends keyof TIntegration['channels'], TTags extends keyof GetChannelByName<TIntegration, ChannelName>['conversation']['tags']>(x: utils.Merge<Arg<client.Client['getOrCreateConversation']>, {
+    channel: utils.Cast<ChannelName, string>;
+    tags: commonTypes.ToNullableTags<TTags>;
+    discriminateByTags?: NoInfer<utils.Cast<TTags[], string[]>>;
+}>) => Promise<GetOrCreateConversationResponse<TIntegration, ChannelName>>;
+export type UpdateConversation<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateConversation']>, {
+    tags?: commonTypes.ToNullableTags<ConversationTags<TIntegration>>;
+}>) => 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: utils.Cast<TEvent, string>;
+        payload: TIntegration['events'][TEvent];
+    }>;
+};
+export type CreateEvent<TIntegration extends common.BaseIntegration> = <TEvent extends keyof TIntegration['events']>(x: utils.Merge<Arg<client.Client['createEvent']>, {
+    type: utils.Cast<TEvent, string>;
+    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?: utils.Cast<keyof TIntegration['events'], string>;
+}>) => Res<client.Client['listEvents']>;
+type MessageResponse<TIntegration extends common.BaseIntegration, TMessage extends keyof EnumerateMessages<TIntegration> = keyof EnumerateMessages<TIntegration>> = {
+    message: utils.Merge<Awaited<Res<client.Client['getMessage']>>['message'], utils.Cast<EnumerateMessages<TIntegration>[TMessage], object>>;
+};
+export type CreateMessage<TIntegration extends common.BaseIntegration> = <TMessage extends keyof EnumerateMessages<TIntegration>>(x: utils.Merge<Arg<client.Client['createMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload: GetMessageByName<TIntegration, TMessage>['payload'];
+    tags: commonTypes.ToTags<keyof GetMessageByName<TIntegration, TMessage>['tags']>;
+}>) => Promise<MessageResponse<TIntegration, TMessage>>;
+type GetOrCreateMessageResponse<TIntegration extends common.BaseIntegration, TMessage extends keyof EnumerateMessages<TIntegration> = keyof EnumerateMessages<TIntegration>> = utils.Merge<Awaited<Res<client.Client['getOrCreateMessage']>>, {
+    message: utils.Merge<Awaited<Res<client.Client['getOrCreateMessage']>>['message'], utils.Cast<EnumerateMessages<TIntegration>[TMessage], object>>;
+}>;
+export type GetOrCreateMessage<TIntegration extends common.BaseIntegration> = <TMessage extends keyof EnumerateMessages<TIntegration>, TTags extends keyof GetMessageByName<TIntegration, TMessage>['tags']>(x: utils.Merge<Arg<client.Client['getOrCreateMessage']>, {
+    type: utils.Cast<TMessage, string>;
+    payload?: GetMessageByName<TIntegration, TMessage>['payload'];
+    tags: commonTypes.ToNullableTags<TTags>;
+    discriminateByTags?: NoInfer<utils.Cast<TTags[], string[]>>;
+}>) => Promise<GetOrCreateMessageResponse<TIntegration, TMessage>>;
+export type GetMessage<TIntegration extends common.BaseIntegration> = (x: Arg<client.Client['getMessage']>) => Promise<MessageResponse<TIntegration>>;
+export type UpdateMessage<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateMessage']>, {
+    tags?: commonTypes.ToNullableTags<MessageTags<TIntegration>>;
+}>) => Promise<MessageResponse<TIntegration>>;
+export type ListMessages<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['listMessages']>, {
+    tags?: commonTypes.ToTags<MessageTags<TIntegration>>;
+}>) => 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: commonTypes.ToTags<UserTags<TIntegration>>;
+    }>;
+};
+export type CreateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['createUser']>, {
+    tags: commonTypes.ToTags<UserTags<TIntegration>>;
+}>) => 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?: commonTypes.ToTags<UserTags<TIntegration>>;
+}>) => Res<client.Client['listUsers']>;
+type GetOrCreateUserResponse<TIntegration extends common.BaseIntegration> = utils.Merge<Awaited<Res<client.Client['getOrCreateUser']>>, {
+    user: utils.Merge<Awaited<Res<client.Client['getOrCreateUser']>>['user'], {
+        tags: commonTypes.ToTags<UserTags<TIntegration>>;
+    }>;
+}>;
+export type GetOrCreateUser<TIntegration extends common.BaseIntegration> = <TTags extends keyof TIntegration['user']['tags']>(x: utils.Merge<Arg<client.Client['getOrCreateUser']>, {
+    tags: commonTypes.ToNullableTags<TTags>;
+    discriminateByTags?: NoInfer<utils.Cast<TTags[], string[]>>;
+}>) => Promise<GetOrCreateUserResponse<TIntegration>>;
+export type UpdateUser<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['updateUser']>, {
+    tags?: commonTypes.ToNullableTags<UserTags<TIntegration>>;
+}>) => Promise<UserResponse<TIntegration>>;
+export type DeleteUser<_TIntegration extends common.BaseIntegration> = client.Client['deleteUser'];
+export type InitializeIncomingMessage<TIntegration extends common.BaseIntegration> = (x: utils.Merge<Arg<client.Client['initializeIncomingMessage']>, {
+    user?: utils.Merge<NonNullable<Arg<client.Client['initializeIncomingMessage']>['user']>, {
+        tags: commonTypes.ToTags<UserTags<TIntegration>>;
+    }>;
+    conversation?: utils.Merge<NonNullable<Arg<client.Client['initializeIncomingMessage']>['conversation']>, {
+        tags: commonTypes.ToTags<ConversationTags<TIntegration>>;
+    }>;
+    message?: utils.Merge<NonNullable<Arg<client.Client['initializeIncomingMessage']>['message']>, {
+        tags: commonTypes.ToTags<MessageTags<TIntegration>>;
+    }>;
+}>) => Promise<{
+    user: Awaited<Res<client.Client['getUser']>>['user'];
+    conversation: Awaited<Res<client.Client['getConversation']>>['conversation'];
+    message?: MessageResponse<TIntegration>;
+}>;
+type StateResponse<TIntegration extends common.BaseIntegration, TState extends keyof TIntegration['states']> = {
+    state: utils.Merge<Awaited<Res<client.Client['getState']>>['state'], {
+        name: utils.Cast<TState, string>;
+        type: utils.Cast<TIntegration['states'][TState]['type'], string>;
+        payload: TIntegration['states'][TState]['payload'];
+    }>;
+    meta: {
+        cached: boolean;
+    };
+};
+export type GetState<TIntegration extends common.BaseIntegration> = <TState extends keyof TIntegration['states']>(x: utils.Merge<Arg<client.Client['getState']>, {
+    type: utils.Cast<TIntegration['states'][TState]['type'], string>;
+    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>;
+    type: utils.Cast<TIntegration['states'][TState]['type'], string>;
+    payload: TIntegration['states'][TState]['payload'] | 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>;
+    type: utils.Cast<TIntegration['states'][TState]['type'], string>;
+    payload: TIntegration['states'][TState]['payload'];
+}>) => 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>;
+    type: utils.Cast<TIntegration['states'][TState]['type'], string>;
+    payload: Partial<TIntegration['states'][TState]['payload']>;
+}>) => 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 TrackAnalytics<_TIntegration extends common.BaseIntegration> = client.Client['trackAnalytics'];
+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>;
+    trackAnalytics: TrackAnalytics<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

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

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

@@ -0,0 +1,57 @@
+import * as utils from '../../utils/type-utils';
+import * as def from '../definition';
+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 BaseState = {
+    type: def.StateType;
+    payload: 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, BaseState>;
+    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/common/generic.test.d.ts

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

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

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

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

@@ -0,0 +1,21 @@
+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/definition.test.d.ts

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

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

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

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

@@ -0,0 +1,130 @@
+import type * as esbuild from 'esbuild';
+import { SchemaTransformOptions } from '../../common/types';
+import { InterfacePackage } from '../../package';
+import * as utils from '../../utils';
+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, InterfaceExtension, IntegrationNetworkDefinition } from './types';
+export * from './types';
+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;
+    attributes?: Record<string, string>;
+    network?: IntegrationNetworkDefinition;
+    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>;
+    __advanced?: SchemaTransformOptions & {
+        esbuild?: Partial<esbuild.BuildOptions>;
+        extraOperations?: Record<string, {
+            enabled: boolean;
+        }>;
+    };
+};
+type EntitiesOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['entities']]: NonNullable<TPackage['definition']['entities']>[K]['schema'];
+};
+type ActionsOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['actions']]: NonNullable<TPackage['definition']['actions']>[K]['input']['schema'];
+};
+type EventsOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['events']]: NonNullable<TPackage['definition']['events']>[K]['schema'];
+};
+type ChannelsOfPackage<TPackage extends InterfacePackage> = {
+    [K in keyof TPackage['definition']['channels']]: {
+        [M in keyof NonNullable<TPackage['definition']['channels']>[K]['messages']]: NonNullable<NonNullable<TPackage['definition']['channels']>[K]['messages']>[M]['schema'];
+    };
+};
+export type ActionOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<ActionDefinition>, 'title' | 'description' | 'billable' | 'cacheable' | 'attributes'> & {
+    name: string;
+}>;
+export type EventOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<EventDefinition>, 'title' | 'description' | 'attributes'> & {
+    name: string;
+}>;
+export type ChannelOverrideProps = utils.types.AtLeastOneProperty<Pick<Required<ChannelDefinition>, 'title' | 'description'> & {
+    name: string;
+    message: {
+        tags: Required<Required<ChannelDefinition>['message']>['tags'];
+    };
+    conversation: {
+        tags: Required<Required<ChannelDefinition>['conversation']>['tags'];
+    };
+}>;
+type ActionOverrides<TInterfaceActionNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceActionNames, ActionOverrideProps>>;
+type EventOverrides<TInterfaceEventNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceEventNames, EventOverrideProps>>;
+type ChannelOverrides<TInterfaceChannelNames extends string = string> = utils.types.AtLeastOneProperty<Record<TInterfaceChannelNames, ChannelOverrideProps>>;
+type ExtensionBuilderInput<TIntegrationEntities extends BaseEntities, _TIntegrationActions extends BaseActions, _TIntegrationEvents extends BaseEvents, _TIntegrationChannels extends BaseChannels> = {
+    entities: SchemaStore<TIntegrationEntities>;
+};
+type ExtensionBuilderOutput<TInterfaceEntities extends BaseEntities, TInterfaceActions extends BaseActions, TInterfaceEvents extends BaseEvents, TInterfaceChannels extends BaseChannels> = {
+    entities: {
+        [K in keyof TInterfaceEntities]: BrandedSchema<z.ZodSchema<z.infer<TInterfaceEntities[K]>>>;
+    };
+    actions?: ActionOverrides<Extract<keyof TInterfaceActions, string>>;
+    events?: EventOverrides<Extract<keyof TInterfaceEvents, string>>;
+    channels?: ChannelOverrides<Extract<keyof TInterfaceChannels, string>>;
+};
+type ExtensionBuilder<TIntegrationEntities extends BaseEntities, TIntegrationActions extends BaseActions, TIntegrationEvents extends BaseEvents, TIntegrationChannels extends BaseChannels, TInterfaceEntities extends BaseEntities, TInterfaceActions extends BaseActions, TInterfaceEvents extends BaseEvents, TInterfaceChannels extends BaseChannels> = (input: ExtensionBuilderInput<TIntegrationEntities, TIntegrationActions, TIntegrationEvents, TIntegrationChannels>) => ExtensionBuilderOutput<TInterfaceEntities, TInterfaceActions, TInterfaceEvents, TInterfaceChannels>;
+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'];
+    readonly __advanced: this['props']['__advanced'];
+    readonly attributes: this['props']['attributes'];
+    readonly network: this['props']['network'];
+    constructor(props: IntegrationDefinitionProps<TName, TVersion, TConfig, TConfigs, TEvents, TActions, TChannels, TStates, TEntities>);
+    get metadata(): {
+        readonly sdkVersion: string;
+    };
+    readonly clone?: (overrides?: Partial<IntegrationDefinitionProps>) => IntegrationDefinition;
+    extend<P extends InterfacePackage>(interfacePkg: P, builder: ExtensionBuilder<TEntities, TActions, TEvents, TChannels, EntitiesOfPackage<P>, ActionsOfPackage<P>, EventsOfPackage<P>, ChannelsOfPackage<P>>): this;
+    private _callBuilder;
+    private _mergeActions;
+    private _mergeEvents;
+    private _mergeChannels;
+    private _mergeMessage;
+    private _mergeObjectSchemas;
+}