@zintrust/workers 0.1.27

package/dist/http/middleware/InfrastructureValidator.js

@@ -0,0 +1,226 @@
+import { Logger } from '@zintrust/core';
+const VALID_DRIVERS = new Set(['database', 'redis', 'memory']);
+const VALID_DEAD_LETTER_POLICIES = new Set(['expire', 'retry', 'dead-letter']);
+const validatePersistence = (persistence) => {
+    if (!persistence)
+        return 'Persistence configuration is required';
+    // Validate persistence driver
+    if (!persistence.driver) {
+        return 'Persistence driver is required';
+    }
+    if (!VALID_DRIVERS.has(persistence.driver)) {
+        return 'Persistence driver must be one of: database, redis, memory';
+    }
+    return null;
+};
+const validateRedis = (redis) => {
+    if (!redis)
+        return 'Redis configuration is required';
+    // Validate env flag
+    if (typeof redis.env !== 'boolean') {
+        return 'Redis env flag must be a boolean';
+    }
+    // Validate required fields when not using env
+    if (!redis.env) {
+        const requiredFieldsError = validateRequiredRedisFields(redis);
+        if (requiredFieldsError)
+            return requiredFieldsError;
+    }
+    // Validate string fields
+    return validateRedisStringFields(redis);
+};
+const validateRequiredRedisFields = (redis) => {
+    if (!redis.host || typeof redis.host !== 'string') {
+        return 'Redis host is required when env is false';
+    }
+    if (redis.port === undefined || redis.port === null) {
+        return 'Redis port is required when env is false';
+    }
+    if (typeof redis.port !== 'string' && typeof redis.port !== 'number') {
+        return 'Redis port must be a string or number';
+    }
+    if (!redis.db || typeof redis.db !== 'string') {
+        return 'Redis db is required when env is false';
+    }
+    return null;
+};
+const validateRedisStringFields = (redis) => {
+    if (redis.host && typeof redis.host !== 'string') {
+        return 'Redis host must be a string';
+    }
+    if (redis.port && typeof redis.port !== 'string' && typeof redis.port !== 'number') {
+        return 'Redis port must be a string or number';
+    }
+    if (redis.db && typeof redis.db !== 'string') {
+        return 'Redis db must be a string';
+    }
+    if (redis.password && typeof redis.password !== 'string') {
+        return 'Redis password must be a string';
+    }
+    return null;
+};
+const validateDeadLetterQueue = (deadLetterQueue) => {
+    if (!deadLetterQueue)
+        return 'DeadLetterQueue configuration is required';
+    // Validate policy
+    if (!deadLetterQueue.policy) {
+        return 'DeadLetterQueue policy is required';
+    }
+    if (!VALID_DEAD_LETTER_POLICIES.has(deadLetterQueue.policy)) {
+        return 'Policy must be one of: expire, retry, dead-letter';
+    }
+    return null;
+};
+const validateCompliance = (compliance) => {
+    if (!compliance)
+        return 'Compliance configuration is required';
+    if (!compliance.config) {
+        return 'Compliance config is required';
+    }
+    if (typeof compliance.config.retentionDays !== 'number' || compliance.config.retentionDays < 0) {
+        return 'Retention days must be a non-negative number';
+    }
+    const MAX_RETENTION_DAYS = 3650; // ~10 years
+    if (compliance.config.retentionDays > MAX_RETENTION_DAYS) {
+        return `Retention days cannot exceed ${MAX_RETENTION_DAYS}`;
+    }
+    return null;
+};
+const validateObservability = (observability) => {
+    if (!observability)
+        return 'Observability configuration is required';
+    if (typeof observability.enabled !== 'boolean') {
+        return 'Observability enabled flag must be a boolean';
+    }
+    return null;
+};
+const validateAutoScaler = (autoScaler) => {
+    if (!autoScaler)
+        return 'AutoScaler configuration is required';
+    if (typeof autoScaler.enabled !== 'boolean') {
+        return 'AutoScaler enabled flag must be a boolean';
+    }
+    if (autoScaler.enabled) {
+        const minWorkersError = validateWorkerCount(autoScaler.minWorkers, 'minWorkers');
+        if (minWorkersError)
+            return minWorkersError;
+        const maxWorkersError = validateWorkerCount(autoScaler.maxWorkers, 'maxWorkers');
+        if (maxWorkersError)
+            return maxWorkersError;
+        if (autoScaler.minWorkers > autoScaler.maxWorkers) {
+            return 'AutoScaler minWorkers cannot be greater than maxWorkers';
+        }
+        const MAX_AUTOSCALER_WORKERS = 1000;
+        if (autoScaler.maxWorkers > MAX_AUTOSCALER_WORKERS) {
+            return `AutoScaler maxWorkers cannot exceed ${MAX_AUTOSCALER_WORKERS}`;
+        }
+    }
+    return null;
+};
+const validateWorkerCount = (value, fieldName) => {
+    if (typeof value !== 'number') {
+        return `AutoScaler ${fieldName} must be a number`;
+    }
+    if (!Number.isInteger(value)) {
+        return `AutoScaler ${fieldName} must be a whole number (integer)`;
+    }
+    if (value < 0) {
+        return `AutoScaler ${fieldName} must be a non-negative number`;
+    }
+    return null;
+};
+const sanitizeInfrastructure = (infrastructure) => {
+    return {
+        ...infrastructure,
+        autoScaler: {
+            ...infrastructure.autoScaler,
+            minWorkers: Math.floor(infrastructure.autoScaler.minWorkers),
+            maxWorkers: Math.floor(infrastructure.autoScaler.maxWorkers),
+        },
+    };
+};
+export const withInfrastructureValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const infrastructure = data['infrastructure'];
+            if (!infrastructure) {
+                return res.setStatus(400).json({
+                    error: 'Infrastructure configuration is required',
+                    code: 'MISSING_INFRASTRUCTURE',
+                });
+            }
+            // Validate persistence
+            const persistenceError = validatePersistence(infrastructure.persistence);
+            if (persistenceError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid persistence configuration',
+                    message: persistenceError,
+                    code: 'INVALID_PERSISTENCE_CONFIG',
+                });
+            }
+            // Validate redis
+            const redisError = validateRedis(infrastructure.redis);
+            if (redisError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid redis configuration',
+                    message: redisError,
+                    code: 'INVALID_REDIS_CONFIG',
+                });
+            }
+            // Validate deadLetterQueue
+            const deadLetterQueueError = validateDeadLetterQueue(infrastructure.deadLetterQueue);
+            if (deadLetterQueueError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid deadLetterQueue configuration',
+                    message: deadLetterQueueError,
+                    code: 'INVALID_DEAD_LETTER_QUEUE_CONFIG',
+                });
+            }
+            // Validate compliance
+            const complianceError = validateCompliance(infrastructure.compliance);
+            if (complianceError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid compliance configuration',
+                    message: complianceError,
+                    code: 'INVALID_COMPLIANCE_CONFIG',
+                });
+            }
+            // Validate observability
+            const observabilityError = validateObservability(infrastructure.observability);
+            if (observabilityError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid observability configuration',
+                    message: observabilityError,
+                    code: 'INVALID_OBSERVABILITY_CONFIG',
+                });
+            }
+            // Validate autoScaler
+            const autoScalerError = validateAutoScaler(infrastructure.autoScaler);
+            if (autoScalerError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid autoScaler configuration',
+                    message: autoScalerError,
+                    code: 'INVALID_AUTO_SCALER_CONFIG',
+                });
+            }
+            // Sanitize infrastructure values
+            const currentBody = req.getBody();
+            const sanitizedInfrastructure = sanitizeInfrastructure(infrastructure);
+            // Update the infrastructure in the request body
+            const updatedBody = {
+                ...currentBody,
+                infrastructure: sanitizedInfrastructure,
+            };
+            req.setBody(updatedBody);
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Infrastructure validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/OptionsValidator.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withOptionsValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/OptionsValidator.js

@@ -0,0 +1,112 @@
+import { Logger } from '@zintrust/core';
+const validateConcurrency = (concurrency) => {
+    if (concurrency === undefined || concurrency === null) {
+        return 'Concurrency is required';
+    }
+    if (typeof concurrency !== 'number') {
+        return 'Concurrency must be a number';
+    }
+    if (!Number.isInteger(concurrency)) {
+        return 'Concurrency must be a whole number (integer)';
+    }
+    if (concurrency < 1) {
+        return 'Concurrency must be at least 1';
+    }
+    const MAX_CONCURRENCY = 200;
+    if (concurrency > MAX_CONCURRENCY) {
+        return `Concurrency cannot exceed ${MAX_CONCURRENCY}`;
+    }
+    return null;
+};
+const validateLimiter = (limiter) => {
+    if (!limiter) {
+        return 'Limiter configuration is required';
+    }
+    // Validate max
+    if (limiter.max === undefined || limiter.max === null) {
+        return 'Limiter max is required';
+    }
+    if (typeof limiter.max !== 'number') {
+        return 'Limiter max must be a number';
+    }
+    if (!Number.isInteger(limiter.max)) {
+        return 'Limiter max must be a whole number (integer)';
+    }
+    if (limiter.max < 1) {
+        return 'Limiter max must be at least 1';
+    }
+    const MAX_LIMITER_MAX = 100000;
+    if (limiter.max > MAX_LIMITER_MAX) {
+        return `Limiter max cannot exceed ${MAX_LIMITER_MAX}`;
+    }
+    // Validate duration
+    if (limiter.duration === undefined || limiter.duration === null) {
+        return 'Limiter duration is required';
+    }
+    if (typeof limiter.duration !== 'number') {
+        return 'Limiter duration must be a number';
+    }
+    if (!Number.isInteger(limiter.duration)) {
+        return 'Limiter duration must be a whole number (integer)';
+    }
+    if (limiter.duration < 1000) {
+        return 'Limiter duration must be at least 1000ms';
+    }
+    const MAX_LIMITER_DURATION = 24 * 60 * 60 * 1000; // 1 day
+    if (limiter.duration > MAX_LIMITER_DURATION) {
+        return `Limiter duration cannot exceed ${MAX_LIMITER_DURATION} ms`;
+    }
+    return null;
+};
+export const withOptionsValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const options = data['options'];
+            if (!options) {
+                return res.setStatus(400).json({
+                    error: 'Options configuration is required',
+                    code: 'MISSING_OPTIONS',
+                });
+            }
+            // Validate concurrency
+            const concurrencyError = validateConcurrency(options.concurrency);
+            if (concurrencyError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid concurrency',
+                    message: concurrencyError,
+                    code: 'INVALID_CONCURRENCY',
+                });
+            }
+            // Validate limiter
+            const limiterError = validateLimiter(options.limiter);
+            if (limiterError) {
+                return res.setStatus(400).json({
+                    error: 'Invalid limiter configuration',
+                    message: limiterError,
+                    code: 'INVALID_LIMITER_CONFIG',
+                });
+            }
+            // Sanitize concurrency to ensure it's an integer
+            const currentBody = req.getBody();
+            const sanitizedOptions = {
+                ...options,
+                concurrency: Math.floor(options.concurrency),
+                limiter: {
+                    ...options.limiter,
+                    max: Math.floor(options.limiter.max),
+                    duration: Math.floor(options.limiter.duration),
+                },
+            };
+            req.setBody({ ...currentBody, options: sanitizedOptions });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Options validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/PayloadSanitizer.d.ts

@@ -0,0 +1,7 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+/**
+ * Middleware to strip unknown properties from the request body.
+ * Only properties included in the allowedKeys list are preserved.
+ */
+export declare const withStrictPayloadKeys: (allowedKeys: string[], handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/PayloadSanitizer.js

@@ -0,0 +1,42 @@
+import { Logger } from '@zintrust/core';
+/**
+ * Middleware to strip unknown properties from the request body.
+ * Only properties included in the allowedKeys list are preserved.
+ */
+export const withStrictPayloadKeys = (allowedKeys, handler) => {
+    const allowedSet = new Set(allowedKeys);
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            if (!data || typeof data !== 'object' || Array.isArray(data)) {
+                // If body is not an object, skip stripping or strictly enforce object?
+                // For worker creation, it must be an object.
+                // Let's rely on downstream validators to complain if data is missing/wrong type.
+                return handler(req, res);
+            }
+            const body = data;
+            const strippedBody = {};
+            let hasUnknowns = false;
+            for (const key of Object.keys(body)) {
+                if (allowedSet.has(key)) {
+                    strippedBody[key] = body[key];
+                }
+                else {
+                    hasUnknowns = true;
+                }
+            }
+            if (hasUnknowns) {
+                // Update the body with sanitized version
+                req.setBody(strippedBody);
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Strict payload validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/ProcessorPathSanitizer.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withProcessorPathValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/ProcessorPathSanitizer.js

@@ -0,0 +1,74 @@
+import { Logger, NodeSingletons } from '@zintrust/core';
+const PROCESSOR_PATH_PATTERN = /^[a-zA-Z0-9/_.-]+\.(ts|js)$/;
+const decodeProcessorPath = (processor) => {
+    return processor
+        .replaceAll('/', '/') // HTML hex entity for /
+        .replaceAll('%2F', '/') // URL encoding for /
+        .replaceAll('.', '.') // HTML hex entity for .
+        .replaceAll('%2E', '.') // URL encoding for .
+        .replaceAll('_', '_') // HTML hex entity for _
+        .replaceAll('%5F', '_') // URL encoding for _
+        .replaceAll('-', '-') // HTML hex entity for -
+        .replaceAll('%2D', '-'); // URL encoding for -
+};
+export const withProcessorPathValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            let processor = data['processor'];
+            if (!processor) {
+                return res.setStatus(400).json({
+                    error: 'Processor path is required',
+                    code: 'MISSING_PROCESSOR_PATH',
+                });
+            }
+            // Decode URL-encoded characters
+            processor = decodeProcessorPath(processor);
+            // Trim whitespace
+            processor = processor.trim();
+            // Prevent path traversal
+            if (processor.includes('..') || processor.startsWith('/')) {
+                return res.setStatus(400).json({
+                    error: 'Invalid processor path',
+                    message: 'Processor path must be relative and cannot contain path traversal',
+                    code: 'INVALID_PROCESSOR_PATH',
+                });
+            }
+            if (!PROCESSOR_PATH_PATTERN.test(processor)) {
+                Logger.error('Processor path validation failed', {
+                    processor,
+                    pattern: PROCESSOR_PATH_PATTERN.toString(),
+                    testResult: PROCESSOR_PATH_PATTERN.test(processor),
+                });
+                return res.setStatus(400).json({
+                    error: 'Invalid processor path',
+                    message: `Processor must be a TypeScript or JavaScript file. Got: "${processor}"`,
+                    code: 'INVALID_PROCESSOR_EXTENSION',
+                });
+            }
+            // Sanitize the processor path (remove any invalid characters just in case)
+            const sanitizedProcessor = processor.replaceAll(/[^a-zA-Z0-9/_.-]/g, '');
+            const path = NodeSingletons.path;
+            // Ensure resolved path stays within repository/app scope
+            const BASE_PROCESSOR_DIR = path.resolve(process.cwd());
+            const resolved = path.resolve(BASE_PROCESSOR_DIR, sanitizedProcessor);
+            if (!resolved.startsWith(BASE_PROCESSOR_DIR)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid processor path',
+                    message: 'Processor path resolves outside of allowed base directory',
+                    code: 'INVALID_PROCESSOR_PATH_TRAVERSAL',
+                });
+            }
+            const currentBody = req.getBody();
+            req.setBody({ ...currentBody, processor: sanitizedProcessor });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Processor path validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/QueueNameSanitizer.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withQueueNameValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/QueueNameSanitizer.js

@@ -0,0 +1,45 @@
+import { Logger } from '@zintrust/core';
+const QUEUE_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+export const withQueueNameValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const queueName = data['queueName'];
+            if (!queueName) {
+                return res.setStatus(400).json({
+                    error: 'Queue name is required',
+                    code: 'MISSING_QUEUE_NAME',
+                });
+            }
+            if (!QUEUE_NAME_PATTERN.test(queueName)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid queue name',
+                    message: 'Queue name must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores',
+                    code: 'INVALID_QUEUE_NAME',
+                });
+            }
+            // Sanitize the queue name
+            const sanitizedQueueName = queueName
+                .trim()
+                .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+                .substring(0, 50);
+            if (sanitizedQueueName.length < 3) {
+                return res.setStatus(400).json({
+                    error: 'Queue name too short after sanitization',
+                    message: 'Queue name must be at least 3 characters long',
+                    code: 'QUEUE_NAME_TOO_SHORT',
+                });
+            }
+            const currentBody = req.getBody();
+            req.setBody({ ...currentBody, queueName: sanitizedQueueName });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Queue name validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/ValidateDriver.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validate Driver Middleware
+ * Ensures the 'driver' query parameter is valid if present.
+ */
+import type { IRequest, IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withDriverValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/ValidateDriver.js

@@ -0,0 +1,20 @@
+/**
+ * Validate Driver Middleware
+ * Ensures the 'driver' query parameter is valid if present.
+ */
+const VALID_DRIVERS = new Set(['database', 'redis', 'memory']);
+export const withDriverValidation = (handler) => {
+    return async (req, res) => {
+        const driver = req.getQueryParam('driver');
+        // Normalize to string if it's an array (take first)
+        const driverValue = Array.isArray(driver) ? driver[0] : driver;
+        if (driverValue && !VALID_DRIVERS.has(driverValue)) {
+            res.setStatus(400).json({
+                error: 'Invalid driver parameter',
+                message: 'Driver must be one of: database, redis, memory',
+            });
+            return;
+        }
+        return handler(req, res);
+    };
+};

package/dist/http/middleware/VersionSanitizer.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withVersionValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/VersionSanitizer.js

@@ -0,0 +1,25 @@
+import { Logger } from '@zintrust/core';
+const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+export const withVersionValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const version = data['version'];
+            if (version && !VERSION_PATTERN.test(version)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid version format',
+                    message: 'Version must follow semantic versioning (e.g., 1.0.0)',
+                    code: 'INVALID_VERSION_FORMAT',
+                });
+            }
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Version validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/WorkerNameSanitizer.d.ts

@@ -0,0 +1,3 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+export declare const withWorkerNameValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/WorkerNameSanitizer.js

@@ -0,0 +1,46 @@
+import { Logger } from '@zintrust/core';
+const WORKER_NAME_PATTERN = /^[a-zA-Z0-9_-]{3,50}$/;
+export const withWorkerNameValidation = (handler) => {
+    return async (req, res) => {
+        try {
+            const data = req.data();
+            const workerName = data['name'];
+            if (!workerName) {
+                return res.setStatus(400).json({
+                    error: 'Worker name is required',
+                    code: 'MISSING_WORKER_NAME',
+                });
+            }
+            if (!WORKER_NAME_PATTERN.test(workerName)) {
+                return res.setStatus(400).json({
+                    error: 'Invalid worker name',
+                    message: 'Worker name must be 3-50 characters long and contain only letters, numbers, hyphens, and underscores',
+                    code: 'INVALID_WORKER_NAME',
+                });
+            }
+            // Sanitize the name
+            const sanitizedName = workerName
+                .trim()
+                .replaceAll(/[^a-zA-Z0-9_-]/g, '')
+                .substring(0, 50);
+            if (sanitizedName.length < 3) {
+                return res.setStatus(400).json({
+                    error: 'Worker name too short after sanitization',
+                    message: 'Worker name must be at least 3 characters long',
+                    code: 'WORKER_NAME_TOO_SHORT',
+                });
+            }
+            // Update the request data with sanitized value
+            const currentBody = req.getBody();
+            req.setBody({ ...currentBody, name: sanitizedName });
+            return handler(req, res);
+        }
+        catch (error) {
+            Logger.error('Worker name validation failed', error);
+            return res.setStatus(500).json({
+                error: 'Internal validation error',
+                code: 'VALIDATION_ERROR',
+            });
+        }
+    };
+};

package/dist/http/middleware/WorkerValidationChain.d.ts

@@ -0,0 +1,27 @@
+import { type IRequest, type IResponse } from '@zintrust/core';
+export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
+/**
+ * Composite middleware for worker creation validation
+ * Validates all required fields for creating a new worker
+ */
+export declare const withCreateWorkerValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for worker update validation
+ * Validates optional fields for updating an existing worker
+ */
+export declare const withUpdateWorkerValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for worker operation validation
+ * Validates worker name for operations like start, stop, restart, etc.
+ */
+export declare const withWorkerOperationValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for bulk operations validation
+ * Validates arrays of worker names and operation parameters
+ */
+export declare const withBulkOperationValidation: (handler: RouteHandler) => RouteHandler;
+/**
+ * Composite middleware for canary deployment validation
+ * Validates canary-specific parameters
+ */
+export declare const withCanaryDeploymentValidation: (handler: RouteHandler) => RouteHandler;