@naman_deep_singh/server-utils 1.0.0 → 1.0.2

package/README.md

@@ -1,238 +1,281 @@
 # @naman_deep_singh/server-utils
 
-Extensible server utilities for Express.js microservices with TypeScript. Provides a plugin-based architecture for building consistent and maintainable server applications.
-
-## Features
-
-- 🚀 **Express Server Factory** - Quick server setup with sensible defaults
-- 🔌 **Plugin System** - Extensible architecture for custom functionality
-- 🏥 **Health Checks** - Built-in health monitoring with custom checks
-- 🛑 **Graceful Shutdown** - Proper cleanup and shutdown handling
-- 📝 **Logging Middleware** - Request logging with customizable formats
-- 🛡️ **Error Handling** - Centralized error handling middleware
-- 🆔 **Request ID** - Automatic request ID generation and tracking
+Extensible server utilities for Express.js microservices with multi-protocol support and TypeScript.
 
 ## Installation
 
 ```bash
 npm install @naman_deep_singh/server-utils
-# or
-pnpm add @naman_deep_singh/server-utils
 ```
 
+## Features
+
+- ✅ **Multi-protocol support** - HTTP, gRPC, JSON-RPC, WebSockets, Webhooks
+- ✅ **Express.js integration** with middleware collection
+- ✅ **Graceful shutdown** handling
+- ✅ **Health checks** with custom checks support
+- ✅ **TypeScript support** with full type safety
+- ✅ **Hybrid exports** - use named imports or namespace imports
+- ✅ **Plugin architecture** for extensibility
+- ✅ **Built-in middleware** - logging, validation, rate limiting, auth
+
 ## Quick Start
 
-### Basic Server
+### Named Imports
 ```typescript
-import { createServer, startServerWithShutdown } from '@naman_deep_singh/server-utils';
+import { createServer } from '@naman_deep_singh/server-utils';
 
-const app = createServer({
+const server = createServer('My API', '1.0.0', {
+  port: 3000,
   cors: true,
-  helmet: true,
-  healthCheck: true
+  helmet: true
 });
 
-app.get('/', (req, res) => {
-  res.json({ message: 'Hello World!' });
+// Add routes
+server.app.get('/users', (req, res) => {
+  res.json({ users: [] });
 });
 
-startServerWithShutdown(app, 3000);
+// Start server
+await server.start();
 ```
 
-### Plugin-Based Architecture
+### Namespace Import
 ```typescript
-import { 
-  createServerWithPlugins, 
-  withHealthCheck, 
-  withLogging, 
-  withErrorHandler,
-  withGracefulShutdown,
-  startServerWithShutdown 
-} from '@naman_deep_singh/server-utils';
-
-const app = createServerWithPlugins(
-  { cors: true, helmet: true },
-  withLogging('detailed'),
-  withHealthCheck('/health', {
-    customChecks: [
-      {
-        name: 'database',
-        check: async () => {
-          // Your database health check
-          return true;
-        }
-      }
-    ]
-  }),
-  withErrorHandler(),
-  withGracefulShutdown({
-    timeout: 15000,
-    onShutdown: async () => {
-      console.log('Cleaning up resources...');
-      // Your cleanup logic
-    }
-  })
-);
-
-// Add your routes
-app.get('/api/users', (req, res) => {
-  res.json({ users: [] });
-});
+import ServerUtils from '@naman_deep_singh/server-utils';
 
-startServerWithShutdown(app, 3000);
+const server = ServerUtils.createServer('My API', '1.0.0');
 ```
 
-## API Reference
+## Multi-Protocol Support
 
-### Server Factory
+### HTTP + Express Routes
+```typescript
+const server = createServer('Multi-Protocol Server', '1.0.0');
 
-#### `createServer(config?: ServerConfig)`
-Creates an Express application with default middleware.
+server.app.get('/api/users', (req, res) => {
+  res.json({ users: [] });
+});
 
-```typescript
-interface ServerConfig {
-  port?: number;
-  cors?: boolean | CorsOptions;
-  helmet?: boolean;
-  json?: boolean;
-  customMiddleware?: express.RequestHandler[];
-  healthCheck?: boolean | string;
-  gracefulShutdown?: boolean;
-}
+await server.start();
 ```
 
-#### `createServerWithPlugins(config, ...plugins)`
-Creates a server and applies multiple plugins.
+### gRPC Support
+```typescript
+// Add gRPC service (requires @grpc/grpc-js)
+server.addGrpcService(userProto.UserService.service, {
+  getUser: (call, callback) => {
+    callback(null, { id: call.request.id, name: 'John' });
+  }
+}, 50051); // Custom port
+```
 
-### Health Checks
+### JSON-RPC Support
+```typescript
+// Add JSON-RPC methods (requires jayson)
+server.addRpcMethods({
+  add: (params, callback) => {
+    callback(null, params[0] + params[1]);
+  },
+  getUser: (id, callback) => {
+    callback(null, { id, name: 'John' });
+  }
+}, '/rpc'); // Custom path
+```
 
-#### `withHealthCheck(path?, config?)`
-Adds health check endpoint as a plugin.
+### WebSocket Support
+```typescript
+// Add Socket.IO (requires socket.io)
+const io = server.addSocketIO({
+  cors: true,
+  onConnection: (socket) => {
+    console.log('Client connected:', socket.id);
+    
+    socket.on('message', (data) => {
+      socket.broadcast.emit('message', data);
+    });
+  },
+  onDisconnection: (socket, reason) => {
+    console.log('Client disconnected:', socket.id, reason);
+  }
+});
+```
 
+### Webhook Support
 ```typescript
-withHealthCheck('/health', {
-  customChecks: [
-    {
-      name: 'redis',
-      check: async () => await redis.ping()
+// Add secure webhooks
+server.addWebhook({
+  path: '/webhooks/github',
+  secret: process.env.GITHUB_WEBHOOK_SECRET,
+  handler: async (payload, headers) => {
+    if (payload.action === 'opened') {
+      console.log('New PR opened:', payload.pull_request.title);
     }
-  ]
-})
+  }
+});
+
+server.addWebhook({
+  path: '/webhooks/stripe',
+  secret: process.env.STRIPE_WEBHOOK_SECRET,
+  handler: async (payload) => {
+    if (payload.type === 'payment_intent.succeeded') {
+      // Handle successful payment
+    }
+  }
+});
 ```
 
-#### `addHealthCheck(app, path?, config?)`
-Directly adds health check to existing app.
+## Built-in Middleware
 
-### Graceful Shutdown
+### Logging Middleware
+```typescript
+import { createLoggingMiddleware, withLogging } from '@naman_deep_singh/server-utils';
+
+// Direct usage
+server.app.use(createLoggingMiddleware('detailed'));
 
-#### `withGracefulShutdown(config?)`
-Adds graceful shutdown as a plugin.
+// Plugin usage
+const server = createServerWithPlugins('My API', '1.0.0', [
+  withLogging('detailed')
+]);
+```
 
+### Validation Middleware
 ```typescript
-withGracefulShutdown({
-  timeout: 10000,
-  onShutdown: async () => {
-    await database.close();
-    await redis.disconnect();
-  }
-})
+import { validateFields } from '@naman_deep_singh/server-utils';
+
+server.app.post('/users', validateFields([
+  { field: 'email', required: true, type: 'email' },
+  { field: 'password', required: true, minLength: 8 },
+  { field: 'age', type: 'number', custom: (value) => value >= 18 || 'Must be 18+' }
+]), (req, res) => {
+  // Validation passed
+  res.json({ success: true });
+});
 ```
 
-#### `startServerWithShutdown(app, port, config?)`
-Starts server with automatic graceful shutdown setup.
+### Rate Limiting
+```typescript
+import { rateLimit } from '@naman_deep_singh/server-utils';
 
-### Middleware Plugins
+server.app.use('/api', rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  maxRequests: 100,
+  message: 'Too many requests'
+}));
+```
 
-#### `withLogging(format?)`
-Adds request logging middleware.
-- `format`: 'simple' | 'detailed'
+### Authentication Middleware
+```typescript
+import { requireAuth } from '@naman_deep_singh/server-utils';
 
-#### `withErrorHandler()`
-Adds centralized error handling middleware.
+server.app.use('/protected', requireAuth({
+  tokenExtractor: (req) => req.headers.authorization?.substring(7),
+  tokenValidator: async (token) => {
+    // Verify JWT token
+    return jwt.verify(token, process.env.JWT_SECRET);
+  }
+}));
+```
 
-#### `withRequestId()`
-Adds request ID generation and tracking.
+## Health Checks
 
-### Custom Plugins
+```typescript
+import { addHealthCheck } from '@naman_deep_singh/server-utils';
 
-Create your own plugins:
+addHealthCheck(server.app, '/health', {
+  customChecks: [
+    {
+      name: 'database',
+      check: async () => {
+        // Check database connection
+        return await db.ping();
+      }
+    },
+    {
+      name: 'redis',
+      check: async () => {
+        return await redis.ping() === 'PONG';
+      }
+    }
+  ]
+});
+```
+
+## Server Management
 
+### Server Information
 ```typescript
-import { ServerPlugin } from '@naman_deep_singh/server-utils';
+const info = server.getInfo();
+console.log(info);
+// {
+//   name: 'My API',
+//   version: '1.0.0',
+//   port: 3000,
+//   uptime: 12345,
+//   status: 'running',
+//   startTime: Date
+// }
+```
 
-const withCustomAuth = (secretKey: string): ServerPlugin => {
-  return (app, config) => {
-    app.use((req, res, next) => {
-      // Your custom auth logic
-      next();
-    });
-  };
-};
+### Graceful Shutdown
+```typescript
+const server = createServer('My API', '1.0.0', {
+  gracefulShutdown: true // Enabled by default
+});
 
-// Use it
-const app = createServerWithPlugins(
-  {},
-  withCustomAuth('my-secret'),
-  withLogging()
-);
+// Handles SIGINT and SIGTERM
+process.on('SIGINT', async () => {
+  await server.stop();
+  process.exit(0);
+});
 ```
 
-## Examples
+## Configuration Options
 
-### Microservice Template
 ```typescript
-import { 
-  createServerWithPlugins,
-  withHealthCheck,
-  withLogging,
-  withErrorHandler,
-  withRequestId,
-  startServerWithShutdown
-} from '@naman_deep_singh/server-utils';
-
-const app = createServerWithPlugins(
-  {
-    cors: {
-      origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
-      credentials: true
-    },
-    helmet: true
-  },
-  withRequestId(),
-  withLogging(process.env.NODE_ENV === 'production' ? 'simple' : 'detailed'),
-  withHealthCheck('/health', {
-    customChecks: [
-      {
-        name: 'database',
-        check: async () => {
-          try {
-            await prisma.$queryRaw`SELECT 1`;
-            return true;
-          } catch {
-            return false;
-          }
-        }
-      }
-    ]
-  }),
-  withErrorHandler()
-);
-
-// Your routes
-app.use('/api', apiRoutes);
-
-const PORT = Number(process.env.PORT) || 3000;
-startServerWithShutdown(app, PORT, {
-  onShutdown: async () => {
-    await prisma.$disconnect();
-  }
-});
+interface ServerConfig {
+  port?: number;                    // Default: 3000
+  cors?: boolean | CorsOptions;     // Default: true
+  helmet?: boolean;                 // Default: true
+  json?: boolean;                   // Default: true
+  customMiddleware?: RequestHandler[];
+  healthCheck?: boolean | string;   // Default: true
+  gracefulShutdown?: boolean;       // Default: true
+  socketIO?: SocketIOConfig;
+}
 ```
 
-## TypeScript Support
+## API Reference
+
+### Core Functions
+- `createServer(name?, version?, config?)` - Create server instance
+- `ExpressServer` - Server class for advanced usage
+
+### Middleware Functions
+- `createLoggingMiddleware(format?)` - Request logging
+- `createErrorHandler()` - Error handling
+- `createValidationMiddleware(rules)` - Input validation
+- `createRateLimitMiddleware(config?)` - Rate limiting
+- `createAuthMiddleware(config)` - Authentication
+
+### Health & Monitoring
+- `createHealthCheck(config?)` - Health check endpoint
+- `addHealthCheck(app, path?, config?)` - Add health check to app
+
+### Graceful Shutdown
+- `createGracefulShutdown(server, config?)` - Setup graceful shutdown
+- `startServerWithShutdown(app, port, config?)` - Start with shutdown handling
 
-Full TypeScript support with comprehensive type definitions for all utilities and plugins.
+## Dependencies
 
-## License
+### Required
+- **express** - Web framework
+- **cors** - CORS middleware
+- **helmet** - Security middleware
+- **cookie-parser** - Cookie parsing
 
-ISC
+### Optional (for specific features)
+- **@grpc/grpc-js** - For gRPC support
+- **jayson** - For JSON-RPC support
+- **socket.io** - For WebSocket support

package/dist/index.d.ts

@@ -1,6 +1,41 @@
-export { createServer, withPlugin, createServerWithPlugins } from './server';
+export { ExpressServer, createServer } from './server';
+export type { ServerInstance, ServerInfo, GrpcService, RpcMethod, WebhookConfig } from './server';
 export { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
 export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
 export { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth, type ValidationRule, type RateLimitConfig, type AuthConfig } from './middleware';
 export { getEnv, getEnvNumber, getEnvBoolean } from './utils';
-export type { ServerConfig, HealthCheckConfig, HealthCheck, GracefulShutdownConfig, ServerPlugin } from './types';
+export type { ServerConfig, HealthCheckConfig, HealthCheck, GracefulShutdownConfig, ServerPlugin, SocketIOConfig, SocketInstance } from './types';
+import { ExpressServer, createServer } from './server';
+import { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
+import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
+import { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth } from './middleware';
+import { getEnv, getEnvNumber, getEnvBoolean } from './utils';
+declare const ServerUtils: {
+    createServer: typeof createServer;
+    ExpressServer: typeof ExpressServer;
+    createHealthCheck: typeof createHealthCheck;
+    withHealthCheck: typeof withHealthCheck;
+    addHealthCheck: typeof addHealthCheck;
+    createGracefulShutdown: typeof createGracefulShutdown;
+    withGracefulShutdown: typeof withGracefulShutdown;
+    startServerWithShutdown: typeof startServerWithShutdown;
+    createLoggingMiddleware: typeof createLoggingMiddleware;
+    createErrorHandler: typeof createErrorHandler;
+    createRequestIdMiddleware: typeof createRequestIdMiddleware;
+    createValidationMiddleware: typeof createValidationMiddleware;
+    createRateLimitMiddleware: typeof createRateLimitMiddleware;
+    createAuthMiddleware: typeof createAuthMiddleware;
+    withLogging: typeof withLogging;
+    withErrorHandler: typeof withErrorHandler;
+    withRequestId: typeof withRequestId;
+    withValidation: typeof withValidation;
+    withRateLimit: typeof withRateLimit;
+    withAuth: typeof withAuth;
+    validateFields: typeof validateFields;
+    rateLimit: typeof rateLimit;
+    requireAuth: typeof requireAuth;
+    getEnv: typeof getEnv;
+    getEnvNumber: typeof getEnvNumber;
+    getEnvBoolean: typeof getEnvBoolean;
+};
+export default ServerUtils;

package/dist/index.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvBoolean = exports.getEnvNumber = exports.getEnv = exports.requireAuth = exports.rateLimit = exports.validateFields = exports.withAuth = exports.withRateLimit = exports.withValidation = exports.withRequestId = exports.withErrorHandler = exports.withLogging = exports.createAuthMiddleware = exports.createRateLimitMiddleware = exports.createValidationMiddleware = exports.createRequestIdMiddleware = exports.createErrorHandler = exports.createLoggingMiddleware = exports.startServerWithShutdown = exports.withGracefulShutdown = exports.createGracefulShutdown = exports.addHealthCheck = exports.withHealthCheck = exports.createHealthCheck = exports.createServerWithPlugins = exports.withPlugin = exports.createServer = void 0;
+exports.getEnvBoolean = exports.getEnvNumber = exports.getEnv = exports.requireAuth = exports.rateLimit = exports.validateFields = exports.withAuth = exports.withRateLimit = exports.withValidation = exports.withRequestId = exports.withErrorHandler = exports.withLogging = exports.createAuthMiddleware = exports.createRateLimitMiddleware = exports.createValidationMiddleware = exports.createRequestIdMiddleware = exports.createErrorHandler = exports.createLoggingMiddleware = exports.startServerWithShutdown = exports.withGracefulShutdown = exports.createGracefulShutdown = exports.addHealthCheck = exports.withHealthCheck = exports.createHealthCheck = exports.createServer = exports.ExpressServer = void 0;
 // Core server utilities
 var server_1 = require("./server");
+Object.defineProperty(exports, "ExpressServer", { enumerable: true, get: function () { return server_1.ExpressServer; } });
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
-Object.defineProperty(exports, "withPlugin", { enumerable: true, get: function () { return server_1.withPlugin; } });
-Object.defineProperty(exports, "createServerWithPlugins", { enumerable: true, get: function () { return server_1.createServerWithPlugins; } });
 // Health check utilities
 var health_1 = require("./health");
 Object.defineProperty(exports, "createHealthCheck", { enumerable: true, get: function () { return health_1.createHealthCheck; } });
@@ -38,3 +37,44 @@ var utils_1 = require("./utils");
 Object.defineProperty(exports, "getEnv", { enumerable: true, get: function () { return utils_1.getEnv; } });
 Object.defineProperty(exports, "getEnvNumber", { enumerable: true, get: function () { return utils_1.getEnvNumber; } });
 Object.defineProperty(exports, "getEnvBoolean", { enumerable: true, get: function () { return utils_1.getEnvBoolean; } });
+// Import all exports for default export
+const server_2 = require("./server");
+const health_2 = require("./health");
+const shutdown_2 = require("./shutdown");
+const middleware_2 = require("./middleware");
+const utils_2 = require("./utils");
+// Default export for namespace usage
+const ServerUtils = {
+    // Server creation
+    createServer: server_2.createServer,
+    ExpressServer: server_2.ExpressServer,
+    // Health checks
+    createHealthCheck: health_2.createHealthCheck,
+    withHealthCheck: health_2.withHealthCheck,
+    addHealthCheck: health_2.addHealthCheck,
+    // Graceful shutdown
+    createGracefulShutdown: shutdown_2.createGracefulShutdown,
+    withGracefulShutdown: shutdown_2.withGracefulShutdown,
+    startServerWithShutdown: shutdown_2.startServerWithShutdown,
+    // Middleware
+    createLoggingMiddleware: middleware_2.createLoggingMiddleware,
+    createErrorHandler: middleware_2.createErrorHandler,
+    createRequestIdMiddleware: middleware_2.createRequestIdMiddleware,
+    createValidationMiddleware: middleware_2.createValidationMiddleware,
+    createRateLimitMiddleware: middleware_2.createRateLimitMiddleware,
+    createAuthMiddleware: middleware_2.createAuthMiddleware,
+    withLogging: middleware_2.withLogging,
+    withErrorHandler: middleware_2.withErrorHandler,
+    withRequestId: middleware_2.withRequestId,
+    withValidation: middleware_2.withValidation,
+    withRateLimit: middleware_2.withRateLimit,
+    withAuth: middleware_2.withAuth,
+    validateFields: middleware_2.validateFields,
+    rateLimit: middleware_2.rateLimit,
+    requireAuth: middleware_2.requireAuth,
+    // Utils
+    getEnv: utils_2.getEnv,
+    getEnvNumber: utils_2.getEnvNumber,
+    getEnvBoolean: utils_2.getEnvBoolean
+};
+exports.default = ServerUtils;

package/dist/middleware.d.ts

@@ -10,7 +10,7 @@ export interface ValidationRule {
     minLength?: number;
     maxLength?: number;
     pattern?: RegExp;
-    custom?: (value: any) => boolean | string;
+    custom?: (value: unknown) => boolean | string;
 }
 export declare function createValidationMiddleware(rules: ValidationRule[]): express.RequestHandler;
 export interface RateLimitConfig {
@@ -22,7 +22,7 @@ export interface RateLimitConfig {
 export declare function createRateLimitMiddleware(config?: RateLimitConfig): express.RequestHandler;
 export interface AuthConfig {
     tokenExtractor?: (req: express.Request) => string | null;
-    tokenValidator?: (token: string) => Promise<any> | any;
+    tokenValidator?: (token: string) => Promise<unknown> | unknown;
     unauthorizedMessage?: string;
 }
 export declare function createAuthMiddleware(config: AuthConfig): express.RequestHandler;

package/dist/middleware.js

@@ -38,14 +38,16 @@ function createErrorHandler() {
         if (res.headersSent) {
             return next(err);
         }
-        const status = err.status || err.statusCode || 500;
+        // Type guard for error objects
+        const errorObj = err;
+        const status = errorObj.status || errorObj.statusCode || 500;
         const message = process.env.NODE_ENV === 'production'
             ? 'Internal Server Error'
-            : err.message;
+            : errorObj.message || 'Unknown error';
         res.status(status).json({
             status: false,
             message,
-            ...(process.env.NODE_ENV !== 'production' && { stack: err.stack })
+            ...(process.env.NODE_ENV !== 'production' && { stack: errorObj.stack })
         });
     };
 }

package/dist/server.d.ts

@@ -1,5 +1,67 @@
 import express from 'express';
-import { ServerConfig, ServerPlugin } from './types';
-export declare function createServer(config?: ServerConfig): express.Application;
-export declare function withPlugin(app: express.Application, plugin: ServerPlugin, config?: ServerConfig): express.Application;
-export declare function createServerWithPlugins(config?: ServerConfig, ...plugins: ServerPlugin[]): express.Application;
+import { Server } from 'http';
+import { ServerConfig, SocketIOConfig } from './types';
+export interface GrpcService {
+    service: Record<string, unknown>;
+    implementation: Record<string, (...args: unknown[]) => unknown>;
+}
+export interface RpcMethod {
+    [key: string]: (params: unknown[], callback: (error: Error | null, result?: unknown) => void) => void;
+}
+export interface WebhookConfig {
+    path: string;
+    secret?: string;
+    handler: (payload: Record<string, unknown>, headers: Record<string, string | string[]>) => void | Promise<void>;
+}
+export interface GrpcServerInstance {
+    start(): void;
+    forceShutdown(): void;
+    addService(service: unknown, implementation: unknown): void;
+    bindAsync(address: string, credentials: unknown, callback: () => void): void;
+}
+export interface ServerInstanceConfig extends Required<Omit<ServerConfig, 'socketIO' | 'name' | 'version'>> {
+    name: string;
+    version: string;
+    startTime: Date;
+    socketIO?: SocketIOConfig;
+}
+export interface ServerInstance {
+    app: express.Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    start(): Promise<ServerInstance>;
+    stop(): Promise<void>;
+    getInfo(): ServerInfo;
+    addGrpcService(service: Record<string, unknown>, implementation: Record<string, (...args: unknown[]) => unknown>, port?: number): void;
+    addRpcMethods(methods: RpcMethod, path?: string): void;
+    addWebhook(config: WebhookConfig): void;
+    addSocketIO(config?: SocketIOConfig): unknown;
+}
+export interface ServerInfo {
+    name: string;
+    version: string;
+    port: number;
+    uptime: number;
+    status: 'starting' | 'running' | 'stopping' | 'stopped';
+    startTime: Date;
+}
+export declare class ExpressServer implements ServerInstance {
+    app: express.Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    private status;
+    private grpcServices;
+    private grpcServer?;
+    private rpcMethods;
+    private socketIO?;
+    constructor(name?: string, version?: string, config?: ServerConfig);
+    private setupMiddleware;
+    start(): Promise<ServerInstance>;
+    stop(): Promise<void>;
+    getInfo(): ServerInfo;
+    addGrpcService(service: Record<string, unknown>, implementation: Record<string, (...args: unknown[]) => unknown>, port?: number): void;
+    addRpcMethods(methods: RpcMethod, path?: string): void;
+    addWebhook(config: WebhookConfig): void;
+    addSocketIO(config?: SocketIOConfig): unknown;
+}
+export declare function createServer(name?: string, version?: string, config?: ServerConfig): ServerInstance;