@hiliosai/sdk 0.1.11 → 0.1.14

package/dist/index.d.ts

@@ -0,0 +1,904 @@
+import { Context, ServiceBroker, ServiceSchema as ServiceSchema$1, ServiceSettingSchema, Service, BrokerOptions, ActionSchema, ServiceEvents, ServiceMethods, ServiceHooks } from 'moleculer';
+import env from '@ltv/env';
+export { default as env } from '@ltv/env';
+
+interface Tenant {
+    id: string;
+    name: string;
+}
+
+declare const UserRole: {
+    readonly OWNER: "OWNER";
+    readonly ADMIN: "ADMIN";
+    readonly MANAGER: "MANAGER";
+    readonly AGENT: "AGENT";
+    readonly VIEWER: "VIEWER";
+};
+interface User {
+    id: string;
+    email: string;
+    roles: string[];
+    permissions: string[];
+    tenantId: string;
+    name: string;
+}
+
+interface ChannelSendOptions {
+    group?: string;
+    maxInFlight?: number;
+    maxRetries?: number;
+    deadLettering?: {
+        enabled?: boolean;
+        queueName?: string;
+    };
+}
+interface SendToChannelMethod {
+    (channelName: string, payload: unknown, options?: ChannelSendOptions): Promise<void>;
+}
+interface AppMeta {
+    user?: User;
+    tenantId?: string;
+    tenantName?: string;
+    userId?: string;
+    channelId?: string;
+    requestId?: string;
+    userAgent?: string;
+    clientIP?: string;
+    [key: string]: unknown;
+}
+interface PermissionHelpers {
+    hasPermission(permission: string): boolean;
+    hasRole(role: string): boolean;
+    isTenantMember(): boolean;
+    isTenantOwner(): boolean;
+    ensureUser(): User;
+    ensureTenant(): Tenant;
+    getUserPermissions(): Promise<string[]>;
+    auditLog(action: string, resource?: unknown, metadata?: Record<string, unknown>): void;
+    createError(message: string, code: string, statusCode?: number): Error;
+}
+type AppContext<TDatasources = unknown, TParams = unknown, TMeta extends AppMeta = AppMeta, TLocals = unknown> = Context<TParams, TMeta, TLocals> & PermissionHelpers & {
+    datasources: TDatasources;
+    broker: Context['broker'] & {
+        sendToChannel: SendToChannelMethod;
+    };
+};
+
+/**
+ * Base datasource interface that all datasources should implement
+ * Provides common structure and optional lifecycle methods
+ */
+interface BaseDatasource<TContext = AppContext> {
+    /**
+     * Datasource name for identification and logging
+     */
+    readonly name: string;
+    /**
+     * Service broker instance for logging, events, and service calls
+     * Always available after datasource initialization
+     */
+    broker: ServiceBroker;
+    /**
+     * Current service context (only available during action execution)
+     * Will be undefined in lifecycle hooks or background tasks
+     */
+    context?: TContext;
+    /**
+     * Optional initialization method
+     * Called when datasource is instantiated
+     */
+    init?(): Promise<void> | void;
+    /**
+     * Optional connection method
+     * Called when service starts if implemented
+     */
+    connect?(): Promise<void> | void;
+    /**
+     * Optional disconnection method
+     * Called when service stops if implemented
+     */
+    disconnect?(): Promise<void> | void;
+    /**
+     * Optional health check method
+     * Can be used to verify datasource is working correctly
+     */
+    healthCheck?(): Promise<boolean> | boolean;
+    /**
+     * Optional method to clear/reset the datasource
+     */
+    clear?(): Promise<void> | void;
+}
+/**
+ * Abstract base class for datasources that provides default implementations
+ * @example
+ * ```typescript
+ * export class UserDatasource extends AbstractDatasource {
+ *   readonly name = 'users';
+ *
+ *   private users: User[] = [];
+ *
+ *   async findById(id: string): Promise<User | undefined> {
+ *     this.broker?.logger.info('Finding user by ID:', id);
+ *     return this.users.find(u => u.id === id);
+ *   }
+ *
+ *   async healthCheck(): Promise<boolean> {
+ *     this.broker?.logger.info('Health check for datasource', this.name);
+ *     return true;
+ *   }
+ * }
+ * ```
+ */
+declare abstract class AbstractDatasource<TContext = AppContext> implements BaseDatasource<TContext> {
+    abstract readonly name: string;
+    /**
+     * Service broker instance - injected by mixin
+     * Always available after initialization
+     */
+    broker: ServiceBroker;
+    /**
+     * Current service context - injected per action
+     * Only available during action execution
+     */
+    context?: TContext;
+    /**
+     * Default health check - always returns true
+     * Override for custom health check logic
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Default clear method - does nothing
+     * Override to implement clearing logic
+     */
+    clear(): Promise<void>;
+}
+
+interface PrismaClientLike {
+    $connect(): Promise<void>;
+    $disconnect(): Promise<void>;
+    $queryRaw: any;
+    $transaction: any;
+    $extends: any;
+    [key: string]: any;
+}
+interface SoftDeleteExtension {
+    softDelete: {
+        [model: string]: {
+            delete: (args: any) => Promise<any>;
+            deleteMany: (args: any) => Promise<any>;
+            restore: (args: any) => Promise<any>;
+        };
+    };
+}
+interface AuditTrailExtension {
+    $auditTrail: {
+        getHistory: (model: string, id: string) => Promise<any[]>;
+        getChanges: (model: string, id: string, from?: Date, to?: Date) => Promise<any[]>;
+    };
+}
+interface TenantExtension {
+    $tenant: {
+        setContext: (tenantId: string) => void;
+        getCurrentTenant: () => string | null;
+    };
+}
+declare global {
+    var __prisma: PrismaClientLike | undefined;
+}
+/**
+ * Prisma datasource that follows singleton pattern and best practices
+ * Supports both provided client instances and automatic initialization
+ *
+ * @example
+ * ```typescript
+ * // Option 1: Let datasource create singleton client
+ * datasources: {
+ *   prisma: PrismaDatasource
+ * }
+ *
+ * // Option 2: Provide custom client
+ * const customClient = new PrismaClient({...});
+ * datasources: {
+ *   prisma: () => new PrismaDatasource(customClient)
+ * }
+ * ```
+ */
+declare class PrismaDatasource<TPrismaClient extends PrismaClientLike = PrismaClientLike, TContext = AppContext> extends AbstractDatasource<TContext> {
+    readonly name = "prisma";
+    private _client;
+    private providedClient;
+    constructor(prismaClient?: TPrismaClient);
+    /**
+     * Get Prisma client instance (singleton pattern)
+     */
+    get client(): TPrismaClient;
+    /**
+     * Initialize Prisma client using singleton pattern or provided instance
+     */
+    private initializePrismaClient;
+    /**
+     * Create a new Prisma client instance
+     * Override this method in subclasses to provide the actual PrismaClient
+     */
+    protected createClient(): TPrismaClient;
+    /**
+     * Apply extensions to the Prisma client
+     * Override this method to add production extensions like soft delete, audit trails, etc.
+     */
+    protected applyExtensions(client: TPrismaClient): TPrismaClient;
+    /**
+     * Get extended client with all applied extensions
+     */
+    get extendedClient(): TPrismaClient;
+    /**
+     * Initialize datasource - called after broker injection
+     */
+    init(): Promise<void>;
+    /**
+     * Called automatically when context is injected
+     * Sets tenant context from service context if available
+     */
+    private updateTenantFromContext;
+    /**
+     * Connect to database - called when service starts
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from database - called when service stops
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Health check - verify database connectivity
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Clear/reset data - useful for testing
+     */
+    clear(): Promise<void>;
+    /**
+     * Transaction wrapper with proper error handling
+     */
+    transaction<T>(fn: (tx: TPrismaClient) => Promise<T>, options?: {
+        maxWait?: number;
+        timeout?: number;
+    }): Promise<T>;
+    /**
+     * Set tenant context for multi-tenant applications
+     * Requires tenant extension to be applied
+     */
+    setTenantContext(tenantId: string): void;
+    /**
+     * Get current tenant context
+     */
+    getCurrentTenant(): string | null;
+    /**
+     * Execute with tenant context (automatically restores previous context)
+     */
+    withTenant<T>(tenantId: string, fn: () => Promise<T>): Promise<T>;
+}
+
+/**
+ * Soft Delete Extension for Prisma
+ * Automatically handles soft deletes by setting deletedAt instead of removing records
+ *
+ * Usage:
+ * ```typescript
+ * import { softDeleteExtension } from './extensions/soft-delete.extension';
+ *
+ * class MyPrismaDS extends PrismaDatasource<PrismaClient> {
+ *   protected applyExtensions(client: PrismaClient) {
+ *     return client.$extends(softDeleteExtension);
+ *   }
+ * }
+ * ```
+ *
+ * Requires models to have `deletedAt DateTime?` field
+ */
+declare const softDeleteExtension: {
+    name: string;
+    query: {
+        $allModels: {
+            findMany({ args, query }: any): Promise<any>;
+            findUnique({ args, query }: any): Promise<any>;
+            findFirst({ args, query }: any): Promise<any>;
+            delete({ args, query }: any): Promise<any>;
+            deleteMany({ args, query }: any): Promise<any>;
+        };
+    };
+    model: {
+        $allModels: {
+            restore<T>(this: T, where: any): Promise<any>;
+            findWithDeleted<T>(this: T, args: any): Promise<any>;
+            findDeleted<T>(this: T, args: any): Promise<any>;
+        };
+    };
+};
+
+/**
+ * Multi-Tenant Extension for Prisma
+ * Automatically filters queries by tenant context for multi-tenant applications
+ *
+ * Usage:
+ * ```typescript
+ * import { createTenantExtension } from './extensions/tenant.extension';
+ *
+ * class MyPrismaDS extends PrismaDatasource<PrismaClient> {
+ *   protected applyExtensions(client: PrismaClient) {
+ *     return client.$extends(createTenantExtension());
+ *   }
+ * }
+ * ```
+ *
+ * Requires models to have `tenantId String` field
+ */
+declare function createTenantExtension(): {
+    name: string;
+    client: {
+        $setTenant(tenantId: string): void;
+        $getCurrentTenant(): string | null;
+        $clearTenant(): void;
+    };
+    query: {
+        $allModels: {
+            findMany({ args, query }: any): Promise<any>;
+            findUnique({ args, query }: any): Promise<any>;
+            findFirst({ args, query }: any): Promise<any>;
+            create({ args, query }: any): Promise<any>;
+            update({ args, query }: any): Promise<any>;
+            delete({ args, query }: any): Promise<any>;
+        };
+    };
+};
+
+/**
+ * Retry Extension for Prisma Transactions
+ * Automatically retries failed transactions with exponential backoff
+ *
+ * Usage:
+ * ```typescript
+ * import { retryExtension } from './extensions/retry.extension';
+ *
+ * class MyPrismaDS extends PrismaDatasource<PrismaClient> {
+ *   protected applyExtensions(client: PrismaClient) {
+ *     return client.$extends(retryExtension);
+ *   }
+ * }
+ * ```
+ */
+declare const retryExtension: {
+    name: string;
+    client: {
+        $retryTransaction<T>(fn: (tx: any) => Promise<T>, options?: {
+            maxRetries?: number;
+            baseDelay?: number;
+            maxDelay?: number;
+            retryableErrors?: string[];
+        }): Promise<T>;
+    };
+};
+
+/**
+ * Datasource constructor registry type
+ * All datasources should implement BaseDatasource interface
+ */
+interface DatasourceConstructorRegistry {
+    [key: string]: new () => BaseDatasource | object;
+}
+/**
+ * Datasource instance registry type
+ */
+interface DatasourceInstanceRegistry {
+    [key: string]: object;
+}
+/**
+ * Datasource context extension
+ */
+interface DatasourceContext extends Context {
+    datasources: DatasourceInstanceRegistry;
+}
+/**
+ * Datasource middleware that injects datasources into the context
+ */
+declare function createDatasourceMiddleware(datasources: DatasourceConstructorRegistry): {
+    localAction(handler: (...args: unknown[]) => unknown): (this: unknown, ctx: Context) => unknown;
+    remoteAction(handler: (...args: unknown[]) => unknown): (this: unknown, ctx: Context) => unknown;
+};
+/**
+ * Type helper for services that use datasources
+ */
+type ServiceWithDatasources<T extends DatasourceInstanceRegistry> = {
+    datasources: T;
+};
+
+interface MemoizeMixinOptions {
+    ttl?: number;
+}
+declare function MemoizeMixin(options?: MemoizeMixinOptions): ServiceSchema$1<ServiceSettingSchema>;
+
+interface HealthCheckOptions {
+    port?: number;
+    readiness?: {
+        path?: string;
+    };
+    liveness?: {
+        path?: string;
+    };
+}
+declare const HEALTH_CHECK_DEFAULTS: {
+    readonly PORT: number;
+    readonly READINESS_PATH: string;
+    readonly LIVENESS_PATH: string;
+};
+declare function CreateHealthCheckMiddleware(opts?: HealthCheckOptions): {
+    created(broker: Service): void;
+    started(): void;
+    stopping(): void;
+    stopped(): void;
+};
+
+declare const PERMISSIONS: {
+    readonly AUTHENTICATED: "authenticated";
+    readonly OWNER: "OWNER";
+    readonly ADMIN: "ADMIN";
+    readonly MANAGER: "MANAGER";
+    readonly AGENT: "AGENT";
+    readonly VIEWER: "VIEWER";
+    readonly DEVELOPER: "DEVELOPER";
+    readonly TENANT_OWNER: "tenant.owner";
+    readonly TENANT_MEMBER: "tenant.member";
+    readonly 'users.read': "users.read";
+    readonly 'users.write': "users.write";
+    readonly 'users.delete': "users.delete";
+    readonly 'tenants.read': "tenants.read";
+    readonly 'tenants.write': "tenants.write";
+    readonly 'tenants.delete': "tenants.delete";
+    readonly 'conversations.read': "conversations.read";
+    readonly 'conversations.write': "conversations.write";
+    readonly 'conversations.delete': "conversations.delete";
+    readonly 'messages.read': "messages.read";
+    readonly 'messages.write': "messages.write";
+    readonly 'settings.read': "settings.read";
+    readonly 'settings.write': "settings.write";
+    readonly 'config.read': "config.read";
+    readonly 'config.write': "config.write";
+    readonly 'billing.read': "billing.read";
+    readonly 'billing.write': "billing.write";
+};
+declare const ROLE_PERMISSIONS: Record<string, string[]>;
+
+declare const configs: BrokerOptions;
+
+declare enum IntegrationPlatform {
+    WHATSAPP = "whatsapp",
+    TELEGRAM = "telegram",
+    SLACK = "slack",
+    EMAIL = "email",
+    SMS = "sms",
+    INSTAGRAM = "instagram",
+    FACEBOOK = "facebook",
+    DISCORD = "discord",
+    WEBCHAT = "webchat",
+    CUSTOM = "custom"
+}
+declare enum IntegrationStatus {
+    CONFIGURED = "CONFIGURED",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    ERROR = "ERROR",
+    SUSPENDED = "SUSPENDED"
+}
+declare enum IntegrationCapability {
+    SEND_MESSAGE = "send_message",
+    RECEIVE_MESSAGE = "receive_message",
+    SEND_IMAGE = "send_image",
+    SEND_VIDEO = "send_video",
+    SEND_AUDIO = "send_audio",
+    SEND_FILE = "send_file",
+    SEND_LOCATION = "send_location",
+    SEND_BUTTONS = "send_buttons",
+    SEND_CAROUSEL = "send_carousel",
+    TYPING_INDICATOR = "typing_indicator",
+    READ_RECEIPT = "read_receipt",
+    GROUP_CHAT = "group_chat",
+    REACTIONS = "reactions",
+    THREADS = "threads",
+    VOICE_CALL = "voice_call",
+    VIDEO_CALL = "video_call"
+}
+
+interface MessageParticipant {
+    id: string;
+    name?: string;
+    avatar?: string;
+    metadata?: Record<string, any>;
+}
+declare enum MessageContentType {
+    TEXT = "text",
+    IMAGE = "image",
+    VIDEO = "video",
+    AUDIO = "audio",
+    FILE = "file",
+    LOCATION = "location",
+    BUTTONS = "buttons",
+    CAROUSEL = "carousel",
+    REACTION = "reaction"
+}
+interface MessageContent {
+    type: MessageContentType;
+    text?: string;
+    media?: {
+        url: string;
+        mimeType?: string;
+        size?: number;
+        thumbnail?: string;
+    };
+    location?: {
+        latitude: number;
+        longitude: number;
+        address?: string;
+    };
+    buttons?: MessageButton[];
+    carousel?: CarouselItem[];
+    reaction?: {
+        emoji: string;
+        messageId: string;
+    };
+    metadata?: Record<string, any>;
+}
+interface MessageButton {
+    id: string;
+    text: string;
+    type: 'postback' | 'url' | 'call';
+    payload?: string;
+    url?: string;
+    phoneNumber?: string;
+}
+interface CarouselItem {
+    title: string;
+    subtitle?: string;
+    imageUrl?: string;
+    buttons?: MessageButton[];
+}
+type MessageDirection = 'incoming' | 'outgoing' | 'internal';
+type MessageType = 'text' | 'image' | 'file' | 'audio' | 'video' | 'location' | 'contact' | 'sticker' | 'template';
+type MessageStatus = 'pending' | 'sent' | 'delivered' | 'read' | 'failed';
+interface Message {
+    id: string;
+    conversationId: string;
+    from: MessageParticipant;
+    to: MessageParticipant;
+    content: MessageContent;
+    direction: MessageDirection;
+    type: MessageType;
+    status: MessageStatus;
+    timestamp: number;
+    platform: IntegrationPlatform;
+    replyTo?: string;
+    threadId?: string;
+    attachments?: MessageAttachment[];
+    metadata?: Record<string, any>;
+}
+interface MessageAttachment {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    url: string;
+    thumbnail?: string;
+    metadata?: Record<string, any>;
+}
+interface PlatformMessage<P = any> {
+    platform: IntegrationPlatform;
+    payload: P;
+}
+interface WebhookEvent<TPayload = any> {
+    tenantId: string;
+    channelId: string;
+    platform: IntegrationPlatform;
+    payload: TPayload;
+    headers: Record<string, string>;
+    timestamp: number;
+}
+interface SendResult {
+    success: boolean;
+    messageId?: string;
+    error?: Error;
+    metadata?: Record<string, any>;
+}
+
+interface BaseSpec {
+    id: string;
+    name: string;
+    platform: IntegrationPlatform;
+    version: string;
+    status: IntegrationStatus;
+    capabilities: IntegrationCapability[];
+    description?: string;
+    icon?: string;
+    documentationUrl?: string;
+}
+interface IntegrationConfig {
+    id: string;
+    tenantId: string;
+    name: string;
+    version: string;
+    config: Record<string, unknown>;
+    credentials: Record<string, string>;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+/**
+ * Utility types for datasources
+ */
+/**
+ * Extract instance types from a datasource constructor registry
+ *
+ * @example
+ * ```typescript
+ * const datasources = {
+ *   user: UserDatasource,
+ *   whatsapp: WhatsAppDatasource,
+ * };
+ *
+ * type MyDatasources = DatasourceInstanceTypes<typeof datasources>;
+ * // Results in: { user: UserDatasource; whatsapp: WhatsAppDatasource; }
+ * ```
+ */
+type DatasourceInstanceTypes<T extends Record<string, new (...args: unknown[]) => unknown>> = {
+    [K in keyof T]: InstanceType<T[K]>;
+};
+
+type InferParamsType<T> = T extends Record<string, any> ? {
+    [K in keyof T]: T[K] extends 'string' ? string : T[K] extends 'number' ? number : T[K] extends 'boolean' ? boolean : T[K] extends 'array' ? any[] : T[K] extends 'object' ? Record<string, any> : T[K] extends {
+        type: 'string';
+    } ? string : T[K] extends {
+        type: 'number';
+    } ? number : T[K] extends {
+        type: 'boolean';
+    } ? boolean : T[K] extends {
+        type: 'array';
+    } ? any[] : T[K] extends {
+        type: 'object';
+    } ? Record<string, any> : unknown;
+} : unknown;
+type ActionSchemaWithContext<TDatasources = unknown, TParams = unknown> = Pick<ActionSchema, 'name' | 'rest' | 'visibility' | 'service' | 'cache' | 'tracing' | 'bulkhead' | 'circuitBreaker' | 'retryPolicy' | 'fallback' | 'hooks'> & {
+    params?: TParams;
+    handler: (ctx: AppContext<TDatasources, InferParamsType<TParams>>) => Promise<unknown> | unknown;
+    permissions?: string | string[];
+};
+type ActionHandler<TDatasources = unknown> = (ctx: AppContext<TDatasources>) => Promise<unknown> | unknown;
+type ServiceActionsSchema<TDatasources = unknown> = {
+    [key: string]: ({
+        params?: any;
+        handler: (ctx: AppContext<TDatasources, any>) => Promise<unknown> | unknown;
+        permissions?: string | string[];
+    } & Pick<ActionSchema, 'name' | 'rest' | 'visibility' | 'service' | 'cache' | 'tracing' | 'bulkhead' | 'circuitBreaker' | 'retryPolicy' | 'fallback' | 'hooks'>) | ActionHandler<TDatasources> | false;
+};
+interface ServiceSchema<TSettings = unknown, TDatasources = unknown> extends Omit<ServiceSchema$1<TSettings>, 'actions'> {
+    name: string;
+    version?: string | number;
+    settings?: TSettings;
+    actions?: ServiceActionsSchema<TDatasources>;
+    events?: ServiceEvents;
+    methods?: ServiceMethods;
+    hooks?: ServiceHooks;
+    dependencies?: string | string[];
+    metadata?: Record<string, any>;
+    created?: (this: ServiceSchema$1<TSettings>) => void | Promise<void>;
+    started?: (this: ServiceSchema$1<TSettings>) => void | Promise<void>;
+    stopped?: (this: ServiceSchema$1<TSettings>) => void | Promise<void>;
+}
+type ServiceConfig<TSettings = unknown, TDatasourceConstructors extends DatasourceConstructorRegistry = DatasourceConstructorRegistry> = ServiceSchema<TSettings, DatasourceInstanceTypes<TDatasourceConstructors>> & {
+    datasources: TDatasourceConstructors;
+};
+interface IntegrationServiceConfig<TSettings = unknown, TDatasourceConstructors extends DatasourceConstructorRegistry = DatasourceConstructorRegistry, TContext extends AppContext<DatasourceInstanceTypes<TDatasourceConstructors>> = AppContext<DatasourceInstanceTypes<TDatasourceConstructors>>> extends ServiceConfig<TSettings, TDatasourceConstructors> {
+    name: string;
+    spec: BaseSpec;
+    normalize<TPayload = any>(webhook: WebhookEvent<TPayload>): Promise<Message[]>;
+    getChannelConfig(ctx: TContext, channelId: string): Promise<IntegrationConfig | null>;
+    validateWebhook?<TPayload = any>(webhook: WebhookEvent<TPayload>): boolean;
+    sendMessage(ctx: TContext, message: Message, config: IntegrationConfig): Promise<SendResult>;
+    verifyWebhook?(params: {
+        mode: string;
+        token: string;
+        challenge: string;
+    }): string | null;
+    checkHealth?(ctx: TContext, config: IntegrationConfig): Promise<{
+        status: 'healthy' | 'unhealthy' | 'degraded';
+        message?: string;
+        details?: Record<string, any>;
+    }>;
+    validateCredentials?(credentials: Record<string, string>): Promise<boolean>;
+    validateSignature?<TPayload = any>(webhook: WebhookEvent<TPayload>): boolean;
+}
+interface IntegrationServiceSchema<TSettings = unknown> extends ServiceSchema$1<TSettings> {
+    spec: BaseSpec;
+    normalize<TPayload = any>(webhook: WebhookEvent<TPayload>): Promise<Message[]>;
+    getChannelConfig(ctx: AppContext, channelId: string): Promise<IntegrationConfig | null>;
+    validateWebhook?<TPayload = any>(webhook: WebhookEvent<TPayload>): boolean;
+    sendMessage(ctx: AppContext, message: Message, config: IntegrationConfig): Promise<SendResult>;
+    verifyWebhook?(params: {
+        mode: string;
+        token: string;
+        challenge: string;
+    }): string | null;
+    checkHealth?(ctx: AppContext, config: IntegrationConfig): Promise<{
+        status: 'healthy' | 'unhealthy' | 'degraded';
+        message?: string;
+        details?: Record<string, any>;
+    }>;
+    validateCredentials?(credentials: Record<string, string>): Promise<boolean>;
+    validateSignature?<TPayload = any>(webhook: WebhookEvent<TPayload>): boolean;
+}
+
+/**
+ * Base namespace for all channels
+ */
+declare const NAMESPACE: string;
+declare const CHANNELS: {
+    readonly WEBHOOK: {
+        readonly PATTERN: `${string}.webhook.*.*`;
+        readonly PREFIX: `${string}.webhook`;
+        readonly build: (tenantId: string, platform: string) => string;
+    };
+    readonly PROCESSING: {
+        readonly PATTERN: `${string}.processing.*.*`;
+        readonly PREFIX: `${string}.processing`;
+        readonly build: (tenantId: string, messageType: string) => string;
+    };
+    readonly RESPONSE: {
+        readonly PATTERN: `${string}.response.*.*`;
+        readonly PREFIX: `${string}.response`;
+        readonly build: (tenantId: string, platform: string) => string;
+    };
+    readonly SYSTEM: {
+        readonly ERRORS: `${string}.system.errors`;
+        readonly METRICS: `${string}.system.metrics`;
+        readonly HEALTH: `${string}.system.health`;
+        readonly INTEGRATION_REGISTERED: `${string}.system.integration.registered`;
+        readonly INTEGRATION_UNREGISTERED: `${string}.system.integration.unregistered`;
+    };
+    readonly DLQ: {
+        readonly WEBHOOK_FAILED: `${string}.dlq.webhook.failed`;
+        readonly SEND_FAILED: `${string}.dlq.send.failed`;
+        readonly PROCESSING_FAILED: `${string}.dlq.processing.failed`;
+        readonly buildSendFailed: (platform: string) => string;
+    };
+};
+/**
+ * Integration-specific channel names
+ */
+declare const INTEGRATION_CHANNELS: {
+    readonly MESSAGE_RECEIVED: `${string}.processing.message.received`;
+    readonly MESSAGE_SENT: `${string}.processing.message.sent`;
+    readonly MESSAGE_FAILED: `${string}.processing.message.failed`;
+};
+type IntegrationChannelName = (typeof INTEGRATION_CHANNELS)[keyof typeof INTEGRATION_CHANNELS];
+
+/**
+ * Channel event payload types for reliable messaging via @moleculer/channels
+ */
+interface IntegrationMessageReceivedPayload {
+    tenantId: string;
+    channelId: string;
+    platform: IntegrationPlatform;
+    message: Message;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationMessageSentPayload {
+    tenantId: string;
+    channelId: string;
+    platform: IntegrationPlatform;
+    messageId?: string;
+    metadata?: Record<string, unknown>;
+    timestamp: number;
+}
+interface IntegrationMessageFailedPayload {
+    tenantId: string;
+    channelId: string;
+    platform: IntegrationPlatform;
+    error: string;
+    message?: Message;
+    timestamp: number;
+    retryCount?: number;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationRegisteredPayload {
+    tenantId: string;
+    channelId: string;
+    platform: IntegrationPlatform;
+    config: Record<string, unknown>;
+    timestamp: number;
+}
+interface IntegrationUnregisteredPayload {
+    tenantId: string;
+    channelId: string;
+    platform: IntegrationPlatform;
+    timestamp: number;
+}
+
+type Permission = keyof typeof PERMISSIONS | string | ((ctx: AppContext, action: ActionSchema) => Promise<boolean> | boolean);
+interface ActionWithPermissions extends ActionSchema {
+    permissions?: Permission | Permission[];
+}
+declare const PermissionsMiddleware: {
+    localAction(handler: (...args: unknown[]) => unknown, action: ActionWithPermissions): ((...args: unknown[]) => unknown) | ((this: Service, ctx: AppContext) => Promise<unknown>);
+};
+
+declare const ContextHelpersMiddleware: {
+    localAction(handler: (...args: unknown[]) => unknown): (this: unknown, ctx: AppContext) => unknown;
+};
+
+/**
+ * Define a service
+ *
+ * @example
+ * ```typescript
+ * export default defineService({
+ *   name: 'user',
+ *
+ *   actions: {
+ *     // Action with schema
+ *     getUser: {
+ *       params: {
+ *         id: 'string'
+ *       },
+ *       handler(ctx) {
+ *         const { tenantId } = ctx.meta;
+ *
+ *         return { id: ctx.params.id, tenantId };
+ *       }
+ *     },
+ *
+ *     // Direct handler
+ *     listUsers(ctx) {
+ *       return [];
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function defineService<TSettings = unknown, TDatasourceConstructors extends DatasourceConstructorRegistry = DatasourceConstructorRegistry>(config: ServiceConfig<TSettings, TDatasourceConstructors>): ServiceSchema$1<TSettings>;
+
+declare function defineIntegration<TSettings = unknown, TDatasourceConstructors extends DatasourceConstructorRegistry = DatasourceConstructorRegistry>(config: IntegrationServiceConfig<TSettings, TDatasourceConstructors>): IntegrationServiceSchema<TSettings>;
+
+declare const nodeEnv: string;
+declare const isDev: boolean;
+declare const isTest: boolean;
+declare const isProd: boolean;
+declare const REDIS_URL: string | undefined;
+
+type Env = typeof env;
+
+/**
+ * Creates a Moleculer mixin for datasource injection
+ * Simple mixin that just instantiates datasources and injects them into context
+ *
+ * @example
+ * ```typescript
+ * import {DatasourceMixin} from '@pkg/sdk';
+ *
+ * export default {
+ *   name: 'users',
+ *   mixins: [DatasourceMixin({
+ *     userDb: UserDatasource,
+ *     cache: CacheDatasource,
+ *   })],
+ *   actions: {
+ *     get: {
+ *       handler(ctx) {
+ *         // Access datasources via ctx.datasources
+ *         return ctx.datasources.userDb.findById(ctx.params.id);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare function DatasourceMixin(datasourceConstructors?: DatasourceConstructorRegistry): Partial<ServiceSchema$1>;
+
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+
+export { AbstractDatasource, type ActionHandler, type ActionSchemaWithContext, type ActionWithPermissions, type AppContext, type AppMeta, type AuditTrailExtension, type BaseDatasource, type BaseSpec, CHANNELS, type CarouselItem, type ChannelSendOptions, ContextHelpersMiddleware, CreateHealthCheckMiddleware, type DatasourceConstructorRegistry, type DatasourceContext, type DatasourceInstanceRegistry, type DatasourceInstanceTypes, DatasourceMixin, type Env, HEALTH_CHECK_DEFAULTS, INTEGRATION_CHANNELS, IntegrationCapability, type IntegrationChannelName, type IntegrationConfig, type IntegrationMessageFailedPayload, type IntegrationMessageReceivedPayload, type IntegrationMessageSentPayload, IntegrationPlatform, type IntegrationRegisteredPayload, type IntegrationServiceConfig, type IntegrationServiceSchema, IntegrationStatus, type IntegrationUnregisteredPayload, MemoizeMixin, type MemoizeMixinOptions, type Message, type MessageAttachment, type MessageButton, type MessageContent, MessageContentType, type MessageDirection, type MessageParticipant, type MessageStatus, type MessageType, NAMESPACE, PERMISSIONS, type Permission, type PermissionHelpers, PermissionsMiddleware, type PlatformMessage, PrismaDatasource, REDIS_URL, ROLE_PERMISSIONS, type SendResult, type SendToChannelMethod, type ServiceActionsSchema, type ServiceConfig, type ServiceSchema, type ServiceWithDatasources, type SoftDeleteExtension, type Tenant, type TenantExtension, type User, UserRole, type WebhookEvent, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, isDev, isProd, isTest, configs as moleculer, nodeEnv, omit, retryExtension, softDeleteExtension };