conduithub 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,16 +1,172 @@
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ConduithubError } from './error/index.mjs';
+export { MissingDependencyError, getPkgManager, setPkgManager } from './error/index.mjs';
+import { p as parseJson } from './shared/conduithub.alPiaJax.mjs';
+export { a as safeStringifyJson, s as stringifyJson } from './shared/conduithub.alPiaJax.mjs';
+import { a as logger } from './shared/conduithub.BNefRQsK.mjs';
+export { c as createLogger, l as levels, s as shouldPublishLog } from './shared/conduithub.BNefRQsK.mjs';
+import { E as ERROR_CODE } from './shared/conduithub.G7ICpZIy.mjs';
+export { K as KafkaPluginConfigSchema, c as conduithubConfigSchema, a as createConfigSchema, e as extendConfigSchema, m as mergeConfigSchemas } from './shared/conduithub.B16qn6pY.mjs';
+export { ConduitHub } from './core/conduit-hub/index.mjs';
 export { ConfigManager } from './core/config-manager/index.mjs';
 export { EventBus } from './core/event-bus/index.mjs';
 export { Hook } from './core/hook/index.mjs';
 export { BasePlugin } from './core/plugin/index.mjs';
 export { ServiceContainer } from './core/service-container/index.mjs';
 export { StateManager } from './core/state-manager/index.mjs';
-export { C as ConduithubError, M as MissingDependencyError, g as getPkgManager, s as setPkgManager } from './shared/conduithub.BDwZXllF.mjs';
-export { p as parseJson, a as safeStringifyJson, s as stringifyJson } from './shared/conduithub.alPiaJax.mjs';
-export { c as createLogger, l as levels, a as logger, s as shouldPublishLog } from './shared/conduithub.BNefRQsK.mjs';
-export { P as PackageManagerUtil, p as packageManagerUtil } from './shared/conduithub.bsiNMTVD.mjs';
+export { K as KafkaPlugin, g as getKafka, i as initKafka, k as kafka, s as shutdownKafka } from './shared/conduithub.BdX_BLza.mjs';
+export { R as RedisPlugin, g as getRedis, i as initRedis, r as redis, s as shutdownRedis } from './shared/conduithub.BzuAKyjY.mjs';
+export { P as PackageManagerUtil, p as packageManagerUtil } from './shared/conduithub.Up0QYVao.mjs';
 export { a as generateShortId, g as generateUuid, i as isValidUuid } from './shared/conduithub.CkOQG3cD.mjs';
 export { P as PluginManager } from './shared/conduithub.DyQQrHW9.mjs';
-export { E as ERROR_CODE } from './shared/conduithub.G7ICpZIy.mjs';
+import 'zod';
 import 'process';
 import 'readline';
 import 'uuid';
+import 'ioredis';
+
+async function loadConfig(options = {}) {
+  const {
+    filePath = "./config.json",
+    envPrefix = "CONDUIT_",
+    defaults = {},
+    schema,
+    override = {}
+  } = options;
+  let config = { ...defaults };
+  try {
+    const fileConfig = await loadConfigFromFile(filePath);
+    config = mergeConfigs(config, fileConfig);
+  } catch (error) {
+    handleConfigLoadError(error, filePath);
+  }
+  const envConfig = loadConfigFromEnv(envPrefix);
+  config = mergeConfigs(config, envConfig, override);
+  if (schema) {
+    return validateConfigWithSchema(config, schema);
+  }
+  return config;
+}
+function handleConfigLoadError(error, filePath) {
+  if (error instanceof Error && error.code !== "ENOENT") {
+    logger.warn(`Could not load config file ${filePath}:`, error.message);
+  }
+}
+function validateConfigWithSchema(config, schema) {
+  const result = schema.safeParse(config);
+  if (!result.success) {
+    throw new ConduithubError(
+      `${ERROR_CODE.INVALID_CONFIG}: ${result.error.message}`
+    );
+  }
+  return result.data;
+}
+async function loadConfigFromFile(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const fileContent = await fs.readFile(absolutePath, "utf-8");
+  try {
+    const parsed = parseJson(fileContent);
+    if (!parsed) {
+      throw new ConduithubError(ERROR_CODE.INVALID_JSON);
+    }
+    return parsed;
+  } catch (jsonError) {
+    if (filePath.endsWith(".js")) {
+      throw new ConduithubError(ERROR_CODE.UNSUPPORTED_CONFIG_FORMAT);
+    }
+    throw jsonError;
+  }
+}
+function loadConfigFromEnv(prefix) {
+  const config = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith(prefix) && value !== void 0) {
+      const configKey = key.slice(prefix.length);
+      const nestedKey = configKey.replace(/__/g, ".");
+      const typedValue = convertEnvValue(value);
+      setNestedValue(config, nestedKey.toLowerCase(), typedValue);
+    }
+  }
+  return config;
+}
+function convertEnvValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return convertPrimitiveValue(value);
+  }
+}
+function convertPrimitiveValue(value) {
+  const lower = value.toLowerCase();
+  if (lower === "true") return true;
+  if (lower === "false") return false;
+  if (lower === "null") return null;
+  if (lower === "undefined") return void 0;
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  return value;
+}
+function setNestedValue(obj, path2, value) {
+  const keys = path2.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function createConfigLoader(schema) {
+  return async (options = {}) => {
+    return loadConfig({
+      ...options,
+      schema
+    });
+  };
+}
+function validateConfig(config, schema) {
+  const result = schema.safeParse(config);
+  if (!result.success) {
+    throw new ConduithubError(
+      `${ERROR_CODE.INVALID_CONFIG}: ${result.error.message}`
+    );
+  }
+  return result.data;
+}
+function mergeConfigs(...configs) {
+  return configs.reduce((merged, config) => deepMerge(merged, config), {});
+}
+function deepMerge(target, source) {
+  if (!isObject(target) || !isObject(source)) {
+    return source;
+  }
+  const result = { ...target };
+  for (const [key, sourceValue] of Object.entries(source)) {
+    const targetValue = result[key];
+    if (isObject(sourceValue) && !Array.isArray(sourceValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function getConfigFilePath(configName, configDir = "./config") {
+  const possibleExtensions = [".json", ".js", ".ts"];
+  for (const ext of possibleExtensions) {
+    const filePath = path.join(configDir, `${configName}${ext}`);
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return path.join(configDir, `${configName}.json`);
+}
+
+export { ConduithubError, ERROR_CODE, createConfigLoader, getConfigFilePath, loadConfig, logger, mergeConfigs, parseJson, validateConfig };

package/dist/plugins/index.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+const plugin = require('../shared/conduithub.0FKJet8c.cjs');
+const schema = require('../shared/conduithub.jH-df3Zd.cjs');
+const client = require('../shared/conduithub.DhMIxMx2.cjs');
+require('node:fs');
+require('node:fs/promises');
+require('node:path');
+require('../shared/conduithub.BNQsddJO.cjs');
+require('../core/conduit-hub/index.cjs');
+require('process');
+require('readline');
+require('uuid');
+require('../core/config-manager/index.cjs');
+require('../shared/conduithub.CmZo_Vuc.cjs');
+require('../shared/conduithub.DQO1dRnn.cjs');
+require('../core/event-bus/index.cjs');
+require('../error/index.cjs');
+require('../shared/conduithub.Bq_7Xj0J.cjs');
+require('../core/hook/index.cjs');
+require('../shared/conduithub.DsOOeNwU.cjs');
+require('../core/service-container/index.cjs');
+require('../core/state-manager/index.cjs');
+require('../core/plugin/index.cjs');
+require('ioredis');
+require('zod');
+
+
+
+exports.KafkaPlugin = plugin.KafkaPlugin;
+exports.getKafka = plugin.getKafka;
+exports.initKafka = plugin.initKafka;
+exports.kafka = plugin.kafka;
+exports.shutdownKafka = plugin.shutdownKafka;
+exports.KafkaPluginConfigSchema = schema.KafkaPluginConfigSchema;
+exports.RedisPlugin = client.RedisPlugin;
+exports.getRedis = client.getRedis;
+exports.initRedis = client.initRedis;
+exports.redis = client.redis;
+exports.shutdownRedis = client.shutdownRedis;

package/dist/plugins/index.d.cts

@@ -0,0 +1,10 @@
+export { KafkaConnectionInfo, KafkaConsumerInfo, KafkaMessage, KafkaPlugin, KafkaPluginConfig, KafkaPluginConfigSchema, KafkaStats, getKafka, initKafka, kafka, shutdownKafka } from './kafka/index.cjs';
+export { RedisPlugin, getRedis, initRedis, redis, shutdownRedis } from './redis/index.cjs';
+import 'kafkajs';
+import '../shared/conduithub.BW-S7Bp_.cjs';
+import 'zod';
+import '../core/hook/index.cjs';
+import '../shared/conduithub.B7aryjPG.cjs';
+import '../shared/conduithub.BZQmkQy7.cjs';
+import '../core/service-container/index.cjs';
+import '../core/state-manager/index.cjs';

package/dist/plugins/index.d.mts

@@ -0,0 +1,10 @@
+export { KafkaConnectionInfo, KafkaConsumerInfo, KafkaMessage, KafkaPlugin, KafkaPluginConfig, KafkaPluginConfigSchema, KafkaStats, getKafka, initKafka, kafka, shutdownKafka } from './kafka/index.mjs';
+export { RedisPlugin, getRedis, initRedis, redis, shutdownRedis } from './redis/index.mjs';
+import 'kafkajs';
+import '../shared/conduithub.GrtzQn_7.mjs';
+import 'zod';
+import '../core/hook/index.mjs';
+import '../shared/conduithub.B7aryjPG.mjs';
+import '../shared/conduithub.BzLwccre.mjs';
+import '../core/service-container/index.mjs';
+import '../core/state-manager/index.mjs';

package/dist/plugins/index.d.ts

@@ -0,0 +1,10 @@
+export { KafkaConnectionInfo, KafkaConsumerInfo, KafkaMessage, KafkaPlugin, KafkaPluginConfig, KafkaPluginConfigSchema, KafkaStats, getKafka, initKafka, kafka, shutdownKafka } from './kafka/index.js';
+export { RedisPlugin, getRedis, initRedis, redis, shutdownRedis } from './redis/index.js';
+import 'kafkajs';
+import '../shared/conduithub.DSAmRivG.js';
+import 'zod';
+import '../core/hook/index.js';
+import '../shared/conduithub.B7aryjPG.js';
+import '../shared/conduithub.DQOWQ-Bx.js';
+import '../core/service-container/index.js';
+import '../core/state-manager/index.js';

package/dist/plugins/index.mjs

@@ -0,0 +1,24 @@
+export { K as KafkaPlugin, g as getKafka, i as initKafka, k as kafka, s as shutdownKafka } from '../shared/conduithub.BdX_BLza.mjs';
+export { K as KafkaPluginConfigSchema } from '../shared/conduithub.B16qn6pY.mjs';
+export { R as RedisPlugin, g as getRedis, i as initRedis, r as redis, s as shutdownRedis } from '../shared/conduithub.BzuAKyjY.mjs';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import '../shared/conduithub.BNefRQsK.mjs';
+import '../core/conduit-hub/index.mjs';
+import 'process';
+import 'readline';
+import 'uuid';
+import '../core/config-manager/index.mjs';
+import '../shared/conduithub.G7ICpZIy.mjs';
+import '../shared/conduithub.alPiaJax.mjs';
+import '../core/event-bus/index.mjs';
+import '../error/index.mjs';
+import '../shared/conduithub.CkOQG3cD.mjs';
+import '../core/hook/index.mjs';
+import '../shared/conduithub.DyQQrHW9.mjs';
+import '../core/service-container/index.mjs';
+import '../core/state-manager/index.mjs';
+import '../core/plugin/index.mjs';
+import 'ioredis';
+import 'zod';

package/dist/plugins/kafka/index.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const plugin = require('../../shared/conduithub.0FKJet8c.cjs');
+const schema = require('../../shared/conduithub.jH-df3Zd.cjs');
+require('node:fs');
+require('node:fs/promises');
+require('node:path');
+require('../../shared/conduithub.BNQsddJO.cjs');
+require('../../core/conduit-hub/index.cjs');
+require('process');
+require('readline');
+require('uuid');
+require('../../core/config-manager/index.cjs');
+require('../../shared/conduithub.CmZo_Vuc.cjs');
+require('../../shared/conduithub.DQO1dRnn.cjs');
+require('../../core/event-bus/index.cjs');
+require('../../error/index.cjs');
+require('../../shared/conduithub.Bq_7Xj0J.cjs');
+require('../../core/hook/index.cjs');
+require('../../shared/conduithub.DsOOeNwU.cjs');
+require('../../core/service-container/index.cjs');
+require('../../core/state-manager/index.cjs');
+require('../../core/plugin/index.cjs');
+require('ioredis');
+require('zod');
+
+
+
+exports.KafkaPlugin = plugin.KafkaPlugin;
+exports.getKafka = plugin.getKafka;
+exports.initKafka = plugin.initKafka;
+exports.kafka = plugin.kafka;
+exports.shutdownKafka = plugin.shutdownKafka;
+exports.KafkaPluginConfigSchema = schema.KafkaPluginConfigSchema;

package/dist/plugins/kafka/index.d.cts

@@ -0,0 +1,250 @@
+import { Admin, ResourceConfigQuery, IResourceConfig, Consumer } from 'kafkajs';
+import { B as BasePlugin } from '../../shared/conduithub.BW-S7Bp_.cjs';
+import { z } from 'zod';
+import '../../core/hook/index.cjs';
+import '../../shared/conduithub.B7aryjPG.cjs';
+import '../../shared/conduithub.BZQmkQy7.cjs';
+import '../../core/service-container/index.cjs';
+import '../../core/state-manager/index.cjs';
+
+declare function initKafka(override?: Partial<KafkaPluginConfig>): Promise<KafkaPlugin>;
+declare function getKafka(): KafkaPlugin;
+declare function shutdownKafka(): Promise<void>;
+declare const kafka: {
+    init: typeof initKafka;
+    get: typeof getKafka;
+    shutdown: typeof shutdownKafka;
+    createTopic: (topic: string, numPartitions?: number, replicationFactor?: number) => Promise<void>;
+    createTopics: (topics: string[]) => Promise<void>;
+    deleteTopic: (topic: string) => Promise<void>;
+    sendMessage: (topic: string, message: unknown, options?: {
+        partition?: number;
+        key?: string;
+        headers?: Record<string, unknown>;
+    }) => Promise<void>;
+    sendBatch: (topic: string, messages: unknown[], options?: {
+        partition?: number;
+        key?: string;
+        headers?: Record<string, unknown>;
+    }[]) => Promise<void>;
+    createConsumer: (topics: string[], handler: Parameters<KafkaPlugin["createConsumer"]>[1], options?: {
+        fromBeginning?: boolean;
+    }) => Promise<void>;
+    stopConsumer: () => Promise<void>;
+    seek: (topic: string, partition: number, offset: string) => Promise<void>;
+    pause: (topics: string[]) => Promise<void>;
+    resume: (topics: string[]) => Promise<void>;
+    commitOffsets: (offsets: Parameters<KafkaPlugin["commitOffsets"]>[0]) => Promise<void>;
+    listTopics: () => Promise<string[]>;
+    getTopicMetadata: (topics?: string[]) => Promise<ReturnType<KafkaPlugin["getTopicMetadata"]>>;
+    describeCluster: () => Promise<ReturnType<KafkaPlugin["describeCluster"]>>;
+    describeConfigs: (resources: Parameters<KafkaPlugin["describeConfigs"]>[0]) => Promise<ReturnType<KafkaPlugin["describeConfigs"]>>;
+    alterConfigs: (resources: Parameters<KafkaPlugin["alterConfigs"]>[0]) => Promise<void>;
+    createPartitions: (topicPartitions: Parameters<KafkaPlugin["createPartitions"]>[0]) => Promise<void>;
+    deleteRecords: (topicPartitions: Parameters<KafkaPlugin["deleteRecords"]>[0]) => Promise<void>;
+    describeGroups: (groupIds: Parameters<KafkaPlugin["describeGroups"]>[0]) => Promise<ReturnType<KafkaPlugin["describeGroups"]>>;
+    listGroups: () => Promise<ReturnType<KafkaPlugin["listGroups"]>>;
+    deleteGroups: (groupIds: Parameters<KafkaPlugin["deleteGroups"]>[0]) => Promise<void>;
+    getConnectionInfo: () => Promise<ReturnType<KafkaPlugin["getConnectionInfo"]>>;
+    getStats: () => Promise<ReturnType<KafkaPlugin["getStats"]>>;
+};
+
+declare const KafkaPluginConfigSchema: z.ZodObject<{
+    clientId: z.ZodDefault<z.ZodString>;
+    brokers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    ssl: z.ZodDefault<z.ZodBoolean>;
+    sasl: z.ZodOptional<z.ZodObject<{
+        mechanism: z.ZodEnum<{
+            plain: "plain";
+            "scram-sha-256": "scram-sha-256";
+            "scram-sha-512": "scram-sha-512";
+            aws: "aws";
+            oauthbearer: "oauthbearer";
+        }>;
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    requestTimeout: z.ZodDefault<z.ZodNumber>;
+    authenticationTimeout: z.ZodDefault<z.ZodNumber>;
+    reauthenticationThreshold: z.ZodDefault<z.ZodNumber>;
+    enforceRequestTimeout: z.ZodDefault<z.ZodBoolean>;
+    retry: z.ZodDefault<z.ZodObject<{
+        initialRetryTime: z.ZodDefault<z.ZodNumber>;
+        retries: z.ZodDefault<z.ZodNumber>;
+        maxRetryTime: z.ZodDefault<z.ZodNumber>;
+        factor: z.ZodDefault<z.ZodNumber>;
+        multiplier: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    producer: z.ZodDefault<z.ZodObject<{
+        allowAutoTopicCreation: z.ZodDefault<z.ZodBoolean>;
+        idempotent: z.ZodDefault<z.ZodBoolean>;
+        maxInFlightRequests: z.ZodDefault<z.ZodNumber>;
+        acks: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        compression: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            gzip: "gzip";
+            snappy: "snappy";
+            lz4: "lz4";
+            zstd: "zstd";
+        }>>;
+        maxBatchSize: z.ZodDefault<z.ZodNumber>;
+        linger: z.ZodDefault<z.ZodNumber>;
+        partitioner: z.ZodDefault<z.ZodEnum<{
+            random: "random";
+            murmur2: "murmur2";
+            murmur2_random: "murmur2_random";
+            consistent: "consistent";
+        }>>;
+    }, z.core.$strip>>;
+    consumer: z.ZodDefault<z.ZodObject<{
+        groupId: z.ZodDefault<z.ZodString>;
+        groupInstanceId: z.ZodOptional<z.ZodString>;
+        sessionTimeout: z.ZodDefault<z.ZodNumber>;
+        rebalanceTimeout: z.ZodDefault<z.ZodNumber>;
+        heartbeatInterval: z.ZodDefault<z.ZodNumber>;
+        maxBytesPerPartition: z.ZodDefault<z.ZodNumber>;
+        minBytes: z.ZodDefault<z.ZodNumber>;
+        maxBytes: z.ZodDefault<z.ZodNumber>;
+        maxWaitTimeInMs: z.ZodDefault<z.ZodNumber>;
+        retryBackoffMs: z.ZodDefault<z.ZodNumber>;
+        autoCommit: z.ZodDefault<z.ZodBoolean>;
+        autoCommitInterval: z.ZodDefault<z.ZodNumber>;
+        autoOffsetReset: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            earliest: "earliest";
+            latest: "latest";
+        }>>;
+        allowAutoTopicCreation: z.ZodDefault<z.ZodBoolean>;
+        maxPollRecords: z.ZodDefault<z.ZodNumber>;
+        maxPollIntervalMs: z.ZodDefault<z.ZodNumber>;
+        readUncommitted: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    admin: z.ZodDefault<z.ZodObject<{
+        clientTimeout: z.ZodDefault<z.ZodNumber>;
+        requestTimeout: z.ZodDefault<z.ZodNumber>;
+        retry: z.ZodDefault<z.ZodObject<{
+            initialRetryTime: z.ZodDefault<z.ZodNumber>;
+            retries: z.ZodDefault<z.ZodNumber>;
+            maxRetryTime: z.ZodDefault<z.ZodNumber>;
+            factor: z.ZodDefault<z.ZodNumber>;
+            multiplier: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    kafkaLogLevel: z.ZodDefault<z.ZodEnum<{
+        NOTHING: "NOTHING";
+        ERROR: "ERROR";
+        WARN: "WARN";
+        INFO: "INFO";
+        DEBUG: "DEBUG";
+    }>>;
+    verboseLogging: z.ZodDefault<z.ZodBoolean>;
+    redactSensitiveLogs: z.ZodDefault<z.ZodBoolean>;
+    topics: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    autoCreateTopics: z.ZodDefault<z.ZodBoolean>;
+    defaultTopicPartitions: z.ZodDefault<z.ZodNumber>;
+    defaultTopicReplicationFactor: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type KafkaPluginConfig = z.infer<typeof KafkaPluginConfigSchema>;
+
+interface KafkaMessage<T = unknown> {
+    topic: string;
+    partition: number;
+    offset: string;
+    key: string | null;
+    value: T;
+    headers: Record<string, string | Buffer | (string | Buffer)[]> | null;
+    timestamp: number;
+}
+interface KafkaConsumerInfo<T = unknown> {
+    topics: string[];
+    handler: (message: KafkaMessage<T>) => Promise<void>;
+    options?: {
+        fromBeginning?: boolean;
+    };
+}
+interface KafkaConnectionInfo {
+    clientId: string;
+    brokers: string[];
+    connected: boolean;
+    ssl: boolean;
+    timestamp: number;
+}
+interface KafkaStats {
+    totalMessagesProduced: number;
+    totalMessagesConsumed: number;
+    successfulMessages: number;
+    failedMessages: number;
+    averageProcessingTime: number;
+    activeTopics: number;
+    activeConsumers: number;
+    lastMessageTime?: number;
+}
+
+declare class KafkaPlugin extends BasePlugin<KafkaPluginConfig> {
+    private kafka;
+    private producer;
+    private consumer;
+    private admin;
+    private isConnected;
+    private consumers;
+    private isConsuming;
+    private stats;
+    private createKafkaLogCreator;
+    constructor(config?: Partial<KafkaPluginConfig>);
+    getMetadata(): {
+        name: string;
+        version: string;
+        description: string;
+        author: string;
+        dependencies: never[];
+        hooks: string[];
+        events: string[];
+    };
+    protected onInitialize(): Promise<void>;
+    protected onStart(): Promise<void>;
+    protected onStop(): Promise<void>;
+    protected onDestroy(): Promise<void>;
+    sendMessage(topic: string, message: unknown, options?: {
+        partition?: number;
+        key?: string;
+        headers?: Record<string, unknown>;
+    }): Promise<void>;
+    sendBatch(topic: string, messages: unknown[], options?: {
+        partition?: number;
+        key?: string;
+        headers?: Record<string, unknown>;
+    }[]): Promise<void>;
+    createConsumer(topics: string[], handler: (message: KafkaMessage) => Promise<void>, options?: {
+        fromBeginning?: boolean;
+    }): Promise<void>;
+    stopConsumer(): Promise<void>;
+    createTopic(topic: string, numPartitions?: number, replicationFactor?: number): Promise<void>;
+    createTopics(topics: string[]): Promise<void>;
+    deleteTopic(topic: string): Promise<void>;
+    listTopics(): Promise<string[]>;
+    getTopicMetadata(topics?: string[]): Promise<ReturnType<Admin["fetchTopicMetadata"]>>;
+    describeCluster(): Promise<ReturnType<Admin["describeCluster"]>>;
+    describeConfigs(resources: ResourceConfigQuery[]): Promise<ReturnType<Admin["describeConfigs"]>>;
+    alterConfigs(resources: IResourceConfig[]): Promise<void>;
+    createPartitions(topicPartitions: Parameters<Admin["createPartitions"]>[0]["topicPartitions"]): Promise<void>;
+    deleteRecords(topicPartitions: Array<{
+        topic: string;
+        partitions: Array<{
+            partition: number;
+            offset: string;
+        }>;
+    }>): Promise<void>;
+    describeGroups(groupIds: string[]): Promise<ReturnType<Admin["describeGroups"]>>;
+    listGroups(): Promise<ReturnType<Admin["listGroups"]>>;
+    deleteGroups(groupIds: string[]): Promise<void>;
+    getConnectionInfo(): KafkaConnectionInfo;
+    getStats(): KafkaStats;
+    seek(topic: string, partition: number, offset: string): Promise<void>;
+    pause(topics: string[]): Promise<void>;
+    resume(topics: string[]): Promise<void>;
+    commitOffsets(offsets: Parameters<Consumer["commitOffsets"]>[0]): Promise<void>;
+}
+
+export { KafkaPlugin, KafkaPluginConfigSchema, getKafka, initKafka, kafka, shutdownKafka };
+export type { KafkaConnectionInfo, KafkaConsumerInfo, KafkaMessage, KafkaPluginConfig, KafkaStats };