@botpress/sdk 0.0.5

package/dist/bot/client.d.ts

@@ -0,0 +1,25 @@
+import { Axios as AxiosInstance } from 'axios';
+import type { Merge, Except } from 'type-fest';
+import type { BotContext } from './context';
+import type { RegisterBotPayload, UnregisterBotPayload, EventReceivedBotPayload } from './implementation';
+type Props<T = any> = Merge<Except<BotContext, 'operation'>, {
+    url: string;
+    data: T;
+}>;
+/**
+ * @description Meant to query your bot server directly (e.g. without going through the Botpress API)
+ */
+export declare class BotClient {
+    private axios;
+    constructor(axiosInstance?: AxiosInstance);
+    register: (props: Props<RegisterBotPayload>) => Promise<any>;
+    unregister: (props: Props<UnregisterBotPayload>) => Promise<any>;
+    eventReceived: (props: Props<EventReceivedBotPayload>) => Promise<any>;
+}
+export declare function formatBotHeaders(ctx: BotContext): {
+    "x-bp-type": string;
+    "x-bot-id": string;
+    "x-bp-operation": "event_received" | "register" | "unregister" | "ping";
+    "x-bp-configuration": string;
+};
+export {};

package/dist/bot/context.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const botOperationSchema: z.ZodEnum<["event_received", "register", "unregister", "ping"]>;
+export type BotOperation = z.infer<typeof botOperationSchema>;
+export type BotContext<Configuration = any, Type extends string = string> = {
+    botId: string;
+    type: Type;
+    operation: BotOperation;
+    configuration: Configuration;
+};

package/dist/bot/implementation.d.ts

@@ -0,0 +1,50 @@
+import type { Bot as BotType, Event } from '@botpress/client';
+import type { EventHandler, MessageHandler, RegisterHandler, StateExpiredHandler, UnregisterHandler } from './state';
+export type RegisterBotPayload = {
+    bot: BotType;
+};
+export type UnregisterBotPayload = {
+    bot: BotType;
+};
+export type EventReceivedBotPayload = {
+    event: Event;
+};
+export type BotDefinitionTags = {
+    messages?: string[];
+    conversations?: string[];
+    users?: string[];
+};
+export type BotDefinitionStateType = 'conversation' | 'user' | 'bot';
+export type BotDefinitionState = {
+    type: BotDefinitionStateType;
+    schema: Record<string, any>;
+    expiry: number;
+};
+export type IntegrationInstance = {
+    enabled: boolean;
+    id: string;
+    configuration: {
+        [key: string]: any;
+    };
+};
+export type BotDefinition = {
+    tags?: BotDefinitionTags;
+    states?: Record<string, BotDefinitionState>;
+    integrations?: IntegrationInstance[];
+};
+export declare class Bot {
+    private _state;
+    readonly tags?: BotDefinitionTags;
+    readonly states?: Record<string, BotDefinitionState>;
+    readonly integrations?: IntegrationInstance[];
+    constructor(def?: BotDefinition);
+    register: (_handler: RegisterHandler) => void;
+    unregister: (_handler: UnregisterHandler) => void;
+    message: (_type: string, handler: MessageHandler) => void;
+    conversation: (_type: string, _handler: MessageHandler) => void;
+    user: (_type: string, _handler: MessageHandler) => void;
+    event: (_type: string, handler: EventHandler) => void;
+    stateExpired: (_type: string, handler: StateExpiredHandler) => void;
+    handler: import("../serve").Handler;
+    start: (port?: number) => Promise<void>;
+}

package/dist/bot/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './implementation';
+export * from './context';

package/dist/bot/server.d.ts

@@ -0,0 +1,3 @@
+import type { Handler } from '../serve';
+import type { BotState } from './state';
+export declare const createBotHandler: (botState: BotState) => Handler;

package/dist/bot/state.d.ts

@@ -0,0 +1,29 @@
+import type { Message, Conversation, User, Event, Client, State } from '@botpress/client';
+import type { BotContext } from './context';
+export type MessageHandler = (props: {
+    client: Client;
+    message: Message;
+    conversation: Conversation;
+    user: User;
+    event: Event;
+    ctx: BotContext;
+}) => Promise<void>;
+export type EventHandler = (props: {
+    client: Client;
+    event: Event;
+    ctx: BotContext;
+}) => Promise<void>;
+export type StateExpiredHandler = (props: {
+    client: Client;
+    state: State;
+    ctx: BotContext;
+}) => Promise<void>;
+export type RegisterHandler = () => Promise<void>;
+export type UnregisterHandler = () => Promise<void>;
+export type BotState = {
+    registerHandlers: RegisterHandler[];
+    unregisterHandlers: UnregisterHandler[];
+    messageHandlers: MessageHandler[];
+    eventHandlers: EventHandler[];
+    stateExpiredHandlers: StateExpiredHandler[];
+};

package/dist/const.d.ts

@@ -0,0 +1,7 @@
+export declare const botIdHeader = "x-bot-id";
+export declare const botUserIdHeader = "x-bot-user-id";
+export declare const integrationIdHeader = "x-integration-id";
+export declare const webhookIdHeader = "x-webhook-id";
+export declare const configurationHeader = "x-bp-configuration";
+export declare const operationHeader = "x-bp-operation";
+export declare const typeHeader = "x-bp-type";

package/dist/error.d.ts

@@ -0,0 +1,18 @@
+declare abstract class BaseError<Type extends string> extends Error {
+    readonly type: Type;
+    readonly message: string;
+    readonly error?: Error | undefined;
+    constructor(type: Type, message: string, error?: Error | undefined);
+    toJSON(): {
+        type: Type;
+        message: string;
+    };
+}
+type BadRequestType = 'BadRequest';
+/**
+ *  A bad request error occurred
+ */
+export declare class BadRequestError extends BaseError<BadRequestType> {
+    constructor(message: string, error?: Error);
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { BotClient } from './bot';
+import { IntegrationClient } from './integration';
+export * as messages from './message';
+export declare const clients: {
+    IntegrationClient: typeof IntegrationClient;
+    BotClient: typeof BotClient;
+};
+export { IntegrationDefinition, IntegrationDefinitionProps, IntegrationImplementation as Integration, IntegrationImplementationProps as IntegrationProps, IntegrationContext, IntegrationOperation, AckFunction, } from './integration';
+export { Bot, BotContext, BotOperation, IntegrationInstance } from './bot';