import { C as ChannelHostCompatibilityEntry, f as findChannelHostCompatibilityEntry, i as isChannelHostCompatibilitySupported } from './channel-host-matrix-N6j_LCTq.js';
export { a as CHANNEL_HOST_COMPATIBILITY_MATRIX, P as PluginCompatibilityStatus } from './channel-host-matrix-N6j_LCTq.js';

declare const CHANNEL_ADAPTER_PLUGIN_TYPE: "channel_adapter";
declare const CHANNEL_ADAPTER_SCHEMA_VERSION: 1;
declare const CHANNEL_ADAPTER_PLUGIN_API_VERSION: "1.0.0";
declare const CHANNEL_ADAPTER_HOST_API_VERSION: "1.0.0";
interface ChannelAdapterManifest {
    readonly schema_version: typeof CHANNEL_ADAPTER_SCHEMA_VERSION;
    readonly plugin_id: string;
    readonly channel_name: string;
    readonly plugin_type: typeof CHANNEL_ADAPTER_PLUGIN_TYPE;
    readonly version: string;
    readonly display_name: string;
    readonly description?: string;
    readonly plugin_api_version: string;
    readonly host_api_version: string;
}
interface ChannelManifestValidationIssue {
    readonly field: string;
    readonly message: string;
}
declare function validateChannelAdapterManifest(value: unknown): readonly ChannelManifestValidationIssue[];

interface ChannelAdapterLogger {
    debug?: (...args: unknown[]) => void;
    info?: (...args: unknown[]) => void;
    warn?: (...args: unknown[]) => void;
    error?: (...args: unknown[]) => void;
}
interface ChannelInboundAttachment {
    readonly type: string;
    readonly url?: string;
    readonly data?: Uint8Array;
    readonly mime_type: string;
    readonly filename?: string;
    readonly size_bytes?: number;
    readonly duration_seconds?: number;
    readonly metadata?: Readonly<Record<string, unknown>>;
}
interface ChannelInboundMessage {
    readonly id: string;
    readonly channel: string;
    readonly sender_id: string;
    readonly sender_name: string;
    readonly identity_id?: string;
    readonly content: string;
    readonly session_id: string;
    readonly scope: "dm" | "group" | "thread";
    readonly timestamp?: number;
    readonly metadata?: Readonly<Record<string, unknown>>;
    readonly attachments?: readonly ChannelInboundAttachment[];
}
interface ChannelOutboundMessage {
    readonly session_id: string;
    readonly content: string;
    readonly attachments?: readonly ChannelInboundAttachment[];
    readonly is_partial?: boolean;
    readonly tts?: boolean;
    readonly metadata?: Readonly<Record<string, unknown>>;
}
interface ChannelAdapterHostServices {
    readonly [key: string]: unknown;
}
interface ChannelAdapterContext<TConfig extends Record<string, unknown> = Record<string, unknown>> {
    readonly logger: ChannelAdapterLogger;
    readonly config: Readonly<TConfig>;
    readonly on_message: (message: ChannelInboundMessage) => Promise<void>;
    readonly host_services?: Readonly<ChannelAdapterHostServices>;
}
interface ChannelAdapter<TConfig extends Record<string, unknown> = Record<string, unknown>> {
    readonly name: string;
    initialize(context: ChannelAdapterContext<TConfig>): Promise<void>;
    start(): Promise<void>;
    stop(): Promise<void>;
    send(message: ChannelOutboundMessage): Promise<void>;
    isHealthy(): boolean;
}
interface ChannelConfigValidationResult {
    readonly valid: boolean;
    readonly errors: readonly string[];
}
interface ChannelAdapterModuleExports<TConfig extends Record<string, unknown> = Record<string, unknown>> {
    readonly manifest: ChannelAdapterManifest;
    readonly validateConfig: (config: unknown) => ChannelConfigValidationResult;
    readonly createChannelAdapter: () => ChannelAdapter<TConfig>;
}

interface ChannelAdapterCertificationIssue {
    readonly code: "module_exports_invalid" | "manifest_invalid" | "compatibility_unsupported" | "config_validator_missing" | "config_invalid" | "factory_missing" | "adapter_invalid";
    readonly message: string;
    readonly field?: string;
}
interface ChannelAdapterCertificationResult {
    readonly ok: boolean;
    readonly manifest?: ChannelAdapterManifest;
    readonly compatibility?: ChannelHostCompatibilityEntry;
    readonly adapter?: ChannelAdapter;
    readonly issues: readonly ChannelAdapterCertificationIssue[];
}
declare function resolveChannelAdapterModuleExports(moduleExports: unknown): ChannelAdapterModuleExports | null;
declare function certifyChannelAdapterModule(params: {
    readonly moduleExports: unknown;
    readonly config?: unknown;
}): ChannelAdapterCertificationResult;

declare class PluginKitError extends Error {
    readonly code: string;
    constructor(message: string, code?: string);
}
declare class PluginManifestValidationError extends PluginKitError {
    readonly issues: readonly ChannelManifestValidationIssue[];
    constructor(message: string, issues?: readonly ChannelManifestValidationIssue[]);
}
declare class PluginCertificationError extends PluginKitError {
    readonly issues: readonly ChannelAdapterCertificationIssue[];
    constructor(message: string, issues?: readonly ChannelAdapterCertificationIssue[]);
}

declare const pluginKit: {
    CHANNEL_ADAPTER_HOST_API_VERSION: "1.0.0";
    CHANNEL_ADAPTER_PLUGIN_API_VERSION: "1.0.0";
    CHANNEL_ADAPTER_PLUGIN_TYPE: "channel_adapter";
    CHANNEL_ADAPTER_SCHEMA_VERSION: 1;
    CHANNEL_HOST_COMPATIBILITY_MATRIX: readonly ChannelHostCompatibilityEntry[];
    validateChannelAdapterManifest: typeof validateChannelAdapterManifest;
    findChannelHostCompatibilityEntry: typeof findChannelHostCompatibilityEntry;
    isChannelHostCompatibilitySupported: typeof isChannelHostCompatibilitySupported;
    certifyChannelAdapterModule: typeof certifyChannelAdapterModule;
    resolveChannelAdapterModuleExports: typeof resolveChannelAdapterModuleExports;
    PluginCertificationError: typeof PluginCertificationError;
    PluginKitError: typeof PluginKitError;
    PluginManifestValidationError: typeof PluginManifestValidationError;
};

export { CHANNEL_ADAPTER_HOST_API_VERSION, CHANNEL_ADAPTER_PLUGIN_API_VERSION, CHANNEL_ADAPTER_PLUGIN_TYPE, CHANNEL_ADAPTER_SCHEMA_VERSION, type ChannelAdapter, type ChannelAdapterCertificationIssue, type ChannelAdapterCertificationResult, type ChannelAdapterContext, type ChannelAdapterHostServices, type ChannelAdapterLogger, type ChannelAdapterManifest, type ChannelAdapterModuleExports, type ChannelConfigValidationResult, ChannelHostCompatibilityEntry, type ChannelInboundAttachment, type ChannelInboundMessage, type ChannelManifestValidationIssue, type ChannelOutboundMessage, PluginCertificationError, PluginKitError, PluginManifestValidationError, certifyChannelAdapterModule, pluginKit as default, findChannelHostCompatibilityEntry, isChannelHostCompatibilitySupported, resolveChannelAdapterModuleExports, validateChannelAdapterManifest };