@cleocode/lafs 1.8.0

package/dist/src/envelope.js

@@ -0,0 +1,136 @@
+import { isRegisteredErrorCode, getRegistryCode, getAgentAction, getDocUrl } from "./errorRegistry.js";
+import { assertEnvelope } from "./validateEnvelope.js";
+export const LAFS_SCHEMA_URL = "https://lafs.dev/schemas/v1/envelope.schema.json";
+function resolveMviLevel(input) {
+    if (typeof input === "boolean") {
+        return input ? "minimal" : "standard";
+    }
+    return input ?? "standard";
+}
+function createMeta(input) {
+    return {
+        specVersion: input.specVersion ?? "1.0.0",
+        schemaVersion: input.schemaVersion ?? "1.0.0",
+        timestamp: input.timestamp ?? new Date().toISOString(),
+        operation: input.operation,
+        requestId: input.requestId,
+        transport: input.transport ?? "sdk",
+        strict: input.strict ?? true,
+        mvi: resolveMviLevel(input.mvi),
+        contextVersion: input.contextVersion ?? 0,
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        ...(input.warnings ? { warnings: input.warnings } : {}),
+    };
+}
+export const CATEGORY_ACTION_MAP = {
+    VALIDATION: 'retry_modified',
+    AUTH: 'authenticate',
+    PERMISSION: 'escalate',
+    NOT_FOUND: 'stop',
+    CONFLICT: 'retry_modified',
+    RATE_LIMIT: 'wait',
+    TRANSIENT: 'retry',
+    INTERNAL: 'escalate',
+    CONTRACT: 'retry_modified',
+    MIGRATION: 'stop',
+};
+function normalizeError(error) {
+    const registryEntry = getRegistryCode(error.code);
+    const category = (error.category ?? registryEntry?.category ?? "INTERNAL");
+    const retryable = error.retryable ?? registryEntry?.retryable ?? false;
+    // Derive agentAction: explicit > registry > category fallback
+    const agentAction = error.agentAction ??
+        getAgentAction(error.code) ??
+        CATEGORY_ACTION_MAP[category];
+    const docUrl = error.docUrl ?? getDocUrl(error.code);
+    const result = {
+        code: error.code,
+        message: error.message,
+        category,
+        retryable,
+        retryAfterMs: error.retryAfterMs ?? null,
+        details: error.details ?? {},
+    };
+    if (agentAction !== undefined) {
+        result.agentAction = agentAction;
+    }
+    if (error.escalationRequired !== undefined) {
+        result.escalationRequired = error.escalationRequired;
+    }
+    if (error.suggestedAction !== undefined) {
+        result.suggestedAction = error.suggestedAction;
+    }
+    if (docUrl !== undefined) {
+        result.docUrl = docUrl;
+    }
+    return result;
+}
+export function createEnvelope(input) {
+    const meta = createMeta(input.meta);
+    if (input.success) {
+        return {
+            $schema: LAFS_SCHEMA_URL,
+            _meta: meta,
+            success: true,
+            result: input.result,
+            ...(input.page !== undefined ? { page: input.page } : {}),
+            ...(input.error !== undefined ? { error: null } : {}),
+            ...(input._extensions !== undefined ? { _extensions: input._extensions } : {}),
+        };
+    }
+    return {
+        $schema: LAFS_SCHEMA_URL,
+        _meta: meta,
+        success: false,
+        // Pass through result if provided — validation tools need actionable data
+        // alongside error metadata. Default to null for traditional error responses.
+        result: input.result ?? null,
+        error: normalizeError(input.error),
+        ...(input.page !== undefined ? { page: input.page } : {}),
+        ...(input._extensions !== undefined ? { _extensions: input._extensions } : {}),
+    };
+}
+export class LafsError extends Error {
+    code;
+    category;
+    retryable;
+    retryAfterMs;
+    details;
+    registered;
+    agentAction;
+    escalationRequired;
+    suggestedAction;
+    docUrl;
+    constructor(error) {
+        super(error.message);
+        this.name = "LafsError";
+        this.code = error.code;
+        this.category = error.category;
+        this.retryable = error.retryable;
+        this.retryAfterMs = error.retryAfterMs;
+        this.details = error.details;
+        this.registered = isRegisteredErrorCode(error.code);
+        if (error.agentAction !== undefined)
+            this.agentAction = error.agentAction;
+        if (error.escalationRequired !== undefined)
+            this.escalationRequired = error.escalationRequired;
+        if (error.suggestedAction !== undefined)
+            this.suggestedAction = error.suggestedAction;
+        if (error.docUrl !== undefined)
+            this.docUrl = error.docUrl;
+    }
+}
+export function parseLafsResponse(input, options = {}) {
+    const envelope = assertEnvelope(input);
+    if (envelope.success) {
+        return envelope.result;
+    }
+    const error = envelope.error;
+    if (!error) {
+        throw new Error("Invalid LAFS envelope: success=false requires error object");
+    }
+    if (options.requireRegisteredErrorCode && !isRegisteredErrorCode(error.code)) {
+        throw new Error(`Unregistered LAFS error code: ${error.code}`);
+    }
+    throw new LafsError(error);
+}

package/dist/src/errorRegistry.d.ts

@@ -0,0 +1,28 @@
+import type { LAFSAgentAction } from "./types.js";
+export interface RegistryCode {
+    code: string;
+    category: string;
+    description: string;
+    retryable: boolean;
+    httpStatus: number;
+    grpcStatus: string;
+    cliExit: number;
+    agentAction?: string;
+    typeUri?: string;
+    docUrl?: string;
+}
+export interface ErrorRegistry {
+    version: string;
+    codes: RegistryCode[];
+}
+export type TransportMapping = {
+    transport: "http" | "grpc" | "cli";
+    value: number | string;
+};
+export declare function getErrorRegistry(): ErrorRegistry;
+export declare function isRegisteredErrorCode(code: string): boolean;
+export declare function getRegistryCode(code: string): RegistryCode | undefined;
+export declare function getAgentAction(code: string): LAFSAgentAction | undefined;
+export declare function getTypeUri(code: string): string | undefined;
+export declare function getDocUrl(code: string): string | undefined;
+export declare function getTransportMapping(code: string, transport: "http" | "grpc" | "cli"): TransportMapping | null;

package/dist/src/errorRegistry.js

@@ -0,0 +1,36 @@
+import errorRegistry from "../schemas/v1/error-registry.json" with { type: "json" };
+export function getErrorRegistry() {
+    return errorRegistry;
+}
+export function isRegisteredErrorCode(code) {
+    const registry = getErrorRegistry();
+    return registry.codes.some((item) => item.code === code);
+}
+export function getRegistryCode(code) {
+    return getErrorRegistry().codes.find((item) => item.code === code);
+}
+export function getAgentAction(code) {
+    const entry = getRegistryCode(code);
+    return entry?.agentAction;
+}
+export function getTypeUri(code) {
+    const entry = getRegistryCode(code);
+    return entry?.typeUri;
+}
+export function getDocUrl(code) {
+    const entry = getRegistryCode(code);
+    return entry?.docUrl;
+}
+export function getTransportMapping(code, transport) {
+    const registryCode = getRegistryCode(code);
+    if (!registryCode) {
+        return null;
+    }
+    if (transport === "http") {
+        return { transport, value: registryCode.httpStatus };
+    }
+    if (transport === "grpc") {
+        return { transport, value: registryCode.grpcStatus };
+    }
+    return { transport, value: registryCode.cliExit };
+}

package/dist/src/fieldExtraction.d.ts

@@ -0,0 +1,67 @@
+import type { LAFSEnvelope, MVILevel } from "./types.js";
+export interface FieldExtractionInput {
+    /** --field <name>: extract single field as plain text, no envelope */
+    fieldFlag?: string;
+    /** --fields <a,b,c>: filter result to these fields, preserve envelope */
+    fieldsFlag?: string | string[];
+    /** --mvi <level>: envelope verbosity (client-requestable levels only) */
+    mviFlag?: MVILevel | string;
+}
+export interface FieldExtractionResolution {
+    /** When set: extract this field as plain text, discard envelope. */
+    field?: string;
+    /** When set: filter result to these fields (envelope preserved). */
+    fields?: string[];
+    /** Resolved MVI level. Defaults to 'standard'. */
+    mvi: MVILevel;
+    /** Which input determined the mvi value: 'flag' when mviFlag was valid, 'default' otherwise. */
+    mviSource: "flag" | "default";
+    /**
+     * True when _fields are requested, indicating the server SHOULD set
+     * _meta.mvi = 'custom' in the response per §9.1.
+     * Separate from the client-resolved mvi level.
+     */
+    expectsCustomMvi: boolean;
+}
+export declare function resolveFieldExtraction(input: FieldExtractionInput): FieldExtractionResolution;
+/**
+ * Extract a named field from a LAFS result object.
+ *
+ * Handles four result shapes:
+ *   1. Direct array: result[0][field]       (list operations where result IS an array)
+ *   2. Direct:       result[field]          (flat result object)
+ *   3. Nested:       result.<key>[field]    (wrapper-entity, e.g. result.task.title)
+ *   4. Array value:  result.<key>[0][field] (wrapper-array, e.g. result.items[0].title)
+ *
+ * Returns the value from the first match only. For array results (shapes 1
+ * and 4), returns the first element's field value only. To extract from all
+ * elements, iterate the array or use applyFieldFilter().
+ *
+ * When multiple wrapper keys contain the requested field (shapes 3 and 4),
+ * the first key in property insertion order wins.
+ *
+ * Returns undefined if not found at any level.
+ */
+export declare function extractFieldFromResult(result: LAFSEnvelope['result'], field: string): unknown;
+/** Convenience wrapper — extracts a field from an envelope's result. */
+export declare function extractFieldFromEnvelope(envelope: LAFSEnvelope, field: string): unknown;
+/**
+ * Filter result fields in a LAFS envelope to the requested subset.
+ *
+ * Handles the same four result shapes as extractFieldFromResult:
+ *   1. Direct array:    project each element
+ *   2. Flat result:     project top-level keys
+ *   3. Wrapper-entity:  project nested entity's keys, preserve wrapper
+ *   4. Wrapper-array:   project each element's keys, preserve wrapper
+ *
+ * Sets _meta.mvi = 'custom' per §9.1.
+ * Returns a new envelope with a new _meta object. Result values are not
+ * deep-cloned; nested object references are shared with the original.
+ * Unknown field names are silently omitted per §9.2.
+ *
+ * When result is a wrapper (shapes 3/4) with multiple keys, each key is
+ * projected independently. Primitive values at the wrapper level (numbers,
+ * strings, booleans) are preserved as-is — _fields is applied to nested
+ * entity or array keys only, not to the wrapper's own primitive keys.
+ */
+export declare function applyFieldFilter(envelope: LAFSEnvelope, fields: string[]): LAFSEnvelope;

package/dist/src/fieldExtraction.js

@@ -0,0 +1,133 @@
+import { LAFSFlagError } from "./flagSemantics.js";
+import { isMVILevel } from "./types.js";
+export function resolveFieldExtraction(input) {
+    if (input.fieldFlag && input.fieldsFlag) {
+        throw new LAFSFlagError('E_FIELD_CONFLICT', 'Cannot combine --field and --fields: --field extracts a single value '
+            + 'as plain text (no envelope); --fields filters the JSON envelope. '
+            + 'Use one or the other.', { conflictingModes: ['single-field-extraction', 'multi-field-filter'] });
+    }
+    const fields = typeof input.fieldsFlag === 'string'
+        ? input.fieldsFlag.split(',').map(f => f.trim()).filter(Boolean)
+        : Array.isArray(input.fieldsFlag)
+            ? input.fieldsFlag.map(f => f.trim()).filter(Boolean)
+            : undefined;
+    // 'custom' is server-set (§9.1) — not a client-requestable level
+    const validMvi = isMVILevel(input.mviFlag) && input.mviFlag !== 'custom';
+    const mvi = validMvi ? input.mviFlag : 'standard';
+    const mviSource = validMvi ? 'flag' : 'default';
+    const hasFields = (fields?.length ?? 0) > 0;
+    return {
+        field: input.fieldFlag || undefined,
+        fields: hasFields ? fields : undefined,
+        mvi,
+        mviSource,
+        expectsCustomMvi: hasFields,
+    };
+}
+/**
+ * Extract a named field from a LAFS result object.
+ *
+ * Handles four result shapes:
+ *   1. Direct array: result[0][field]       (list operations where result IS an array)
+ *   2. Direct:       result[field]          (flat result object)
+ *   3. Nested:       result.<key>[field]    (wrapper-entity, e.g. result.task.title)
+ *   4. Array value:  result.<key>[0][field] (wrapper-array, e.g. result.items[0].title)
+ *
+ * Returns the value from the first match only. For array results (shapes 1
+ * and 4), returns the first element's field value only. To extract from all
+ * elements, iterate the array or use applyFieldFilter().
+ *
+ * When multiple wrapper keys contain the requested field (shapes 3 and 4),
+ * the first key in property insertion order wins.
+ *
+ * Returns undefined if not found at any level.
+ */
+export function extractFieldFromResult(result, field) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    // Shape 1: result is a direct array
+    if (Array.isArray(result)) {
+        if (result.length === 0)
+            return undefined;
+        const first = result[0];
+        if (first && typeof first === 'object' && field in first)
+            return first[field];
+        return undefined;
+    }
+    // Shape 2: direct property on result object
+    const record = result;
+    if (field in record)
+        return record[field];
+    // Shapes 3 & 4: one level down (first matching key in insertion order wins)
+    for (const value of Object.values(record)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const nested = value;
+            if (field in nested)
+                return nested[field];
+        }
+        if (Array.isArray(value) && value.length > 0) {
+            const first = value[0];
+            if (first && typeof first === 'object' && field in first)
+                return first[field];
+        }
+    }
+    return undefined;
+}
+/** Convenience wrapper — extracts a field from an envelope's result. */
+export function extractFieldFromEnvelope(envelope, field) {
+    return extractFieldFromResult(envelope.result, field);
+}
+/**
+ * Filter result fields in a LAFS envelope to the requested subset.
+ *
+ * Handles the same four result shapes as extractFieldFromResult:
+ *   1. Direct array:    project each element
+ *   2. Flat result:     project top-level keys
+ *   3. Wrapper-entity:  project nested entity's keys, preserve wrapper
+ *   4. Wrapper-array:   project each element's keys, preserve wrapper
+ *
+ * Sets _meta.mvi = 'custom' per §9.1.
+ * Returns a new envelope with a new _meta object. Result values are not
+ * deep-cloned; nested object references are shared with the original.
+ * Unknown field names are silently omitted per §9.2.
+ *
+ * When result is a wrapper (shapes 3/4) with multiple keys, each key is
+ * projected independently. Primitive values at the wrapper level (numbers,
+ * strings, booleans) are preserved as-is — _fields is applied to nested
+ * entity or array keys only, not to the wrapper's own primitive keys.
+ */
+export function applyFieldFilter(envelope, fields) {
+    if (fields.length === 0 || envelope.result === null)
+        return envelope;
+    const pick = (obj) => Object.fromEntries(fields.filter(f => f in obj).map(f => [f, obj[f]]));
+    let filtered;
+    if (Array.isArray(envelope.result)) {
+        // Shape 1: direct array
+        filtered = envelope.result.map(pick);
+    }
+    else {
+        const record = envelope.result;
+        const topLevelMatch = fields.some(f => f in record);
+        if (topLevelMatch) {
+            // Shape 2: flat result
+            filtered = pick(record);
+        }
+        else {
+            // Shapes 3 & 4: wrapper — apply pick one level down, preserve wrapper keys
+            filtered = Object.fromEntries(Object.entries(record).map(([k, v]) => {
+                if (Array.isArray(v)) {
+                    return [k, v.map(item => pick(item))];
+                }
+                if (v && typeof v === 'object') {
+                    return [k, pick(v)];
+                }
+                return [k, v];
+            }));
+        }
+    }
+    return {
+        ...envelope,
+        _meta: { ...envelope._meta, mvi: 'custom' },
+        result: filtered,
+    };
+}

package/dist/src/flagResolver.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Unified cross-layer flag resolver.
+ *
+ * Composes format resolution (§5.1–5.3) with field extraction resolution (§9.2)
+ * and validates cross-layer interactions per §5.4.
+ *
+ * @since 1.6.0
+ */
+import { type FlagResolution } from './flagSemantics.js';
+import { type FieldExtractionResolution } from './fieldExtraction.js';
+/** Combined input for both format and field extraction layers. */
+export interface UnifiedFlagInput {
+    human?: boolean;
+    json?: boolean;
+    quiet?: boolean;
+    requestedFormat?: 'json' | 'human';
+    projectDefault?: 'json' | 'human';
+    userDefault?: 'json' | 'human';
+    /**
+     * TTY detection hint. When true, defaults to human format if no
+     * explicit format flag or project/user default is set.
+     * CLI tools should pass `process.stdout.isTTY ?? false`.
+     */
+    tty?: boolean;
+    field?: string;
+    fields?: string | string[];
+    mvi?: string;
+}
+/** Combined resolution result with cross-layer warnings. */
+export interface UnifiedFlagResolution {
+    /** Resolved format layer. */
+    format: FlagResolution;
+    /** Resolved field extraction layer. */
+    fields: FieldExtractionResolution;
+    /** Warnings for cross-layer interactions (non-fatal). */
+    warnings: string[];
+}
+/**
+ * Resolve all flags across both layers and validate cross-layer semantics.
+ *
+ * Per §5.4, cross-layer combinations are valid but MAY produce warnings.
+ * Format-layer conflicts (E_FORMAT_CONFLICT) and field-layer conflicts
+ * (E_FIELD_CONFLICT) still throw as before — they are delegated to the
+ * existing single-layer resolvers.
+ */
+export declare function resolveFlags(input: UnifiedFlagInput): UnifiedFlagResolution;

package/dist/src/flagResolver.js

@@ -0,0 +1,47 @@
+/**
+ * Unified cross-layer flag resolver.
+ *
+ * Composes format resolution (§5.1–5.3) with field extraction resolution (§9.2)
+ * and validates cross-layer interactions per §5.4.
+ *
+ * @since 1.6.0
+ */
+import { resolveOutputFormat } from './flagSemantics.js';
+import { resolveFieldExtraction } from './fieldExtraction.js';
+/**
+ * Resolve all flags across both layers and validate cross-layer semantics.
+ *
+ * Per §5.4, cross-layer combinations are valid but MAY produce warnings.
+ * Format-layer conflicts (E_FORMAT_CONFLICT) and field-layer conflicts
+ * (E_FIELD_CONFLICT) still throw as before — they are delegated to the
+ * existing single-layer resolvers.
+ */
+export function resolveFlags(input) {
+    const formatInput = {
+        humanFlag: input.human,
+        jsonFlag: input.json,
+        quiet: input.quiet,
+        requestedFormat: input.requestedFormat,
+        projectDefault: input.projectDefault,
+        userDefault: input.userDefault,
+        tty: input.tty,
+    };
+    const format = resolveOutputFormat(formatInput);
+    const fieldInput = {
+        fieldFlag: input.field,
+        fieldsFlag: input.fields,
+        mviFlag: input.mvi,
+    };
+    const fields = resolveFieldExtraction(fieldInput);
+    // Cross-layer validation (§5.4)
+    const warnings = [];
+    if (format.format === 'human' && fields.field) {
+        warnings.push(`Cross-layer: --human + --field "${fields.field}". ` +
+            'Field extraction applies first, then human rendering (§5.4.1).');
+    }
+    if (format.format === 'human' && fields.fields && fields.fields.length > 0) {
+        warnings.push(`Cross-layer: --human + --fields [${fields.fields.join(', ')}]. ` +
+            'Field filtering applies first, then human rendering (§5.4.1).');
+    }
+    return { format, fields, warnings };
+}

package/dist/src/flagSemantics.d.ts

@@ -0,0 +1,16 @@
+import type { FlagInput, LAFSError, LAFSErrorCategory } from "./types.js";
+export interface FlagResolution {
+    format: "json" | "human";
+    source: "flag" | "project" | "user" | "default";
+    /** When true, suppress non-essential output for scripting */
+    quiet: boolean;
+}
+export declare class LAFSFlagError extends Error implements LAFSError {
+    code: string;
+    category: LAFSErrorCategory;
+    retryable: boolean;
+    retryAfterMs: number | null;
+    details: Record<string, unknown>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export declare function resolveOutputFormat(input: FlagInput): FlagResolution;

package/dist/src/flagSemantics.js

@@ -0,0 +1,45 @@
+import { getRegistryCode } from "./errorRegistry.js";
+export class LAFSFlagError extends Error {
+    code;
+    category;
+    retryable;
+    retryAfterMs;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = "LAFSFlagError";
+        this.code = code;
+        const entry = getRegistryCode(code);
+        this.category = (entry?.category ?? "CONTRACT");
+        this.retryable = entry?.retryable ?? false;
+        this.retryAfterMs = null;
+        this.details = details;
+    }
+}
+export function resolveOutputFormat(input) {
+    if (input.humanFlag && input.jsonFlag) {
+        throw new LAFSFlagError("E_FORMAT_CONFLICT", "Cannot combine --human and --json in the same invocation.");
+    }
+    const quiet = input.quiet ?? false;
+    if (input.requestedFormat) {
+        return { format: input.requestedFormat, source: "flag", quiet };
+    }
+    if (input.humanFlag) {
+        return { format: "human", source: "flag", quiet };
+    }
+    if (input.jsonFlag) {
+        return { format: "json", source: "flag", quiet };
+    }
+    if (input.projectDefault) {
+        return { format: input.projectDefault, source: "project", quiet };
+    }
+    if (input.userDefault) {
+        return { format: input.userDefault, source: "user", quiet };
+    }
+    // TTY terminals default to human-readable output for usability.
+    // Non-TTY (piped, CI, agents) defaults to JSON per LAFS protocol.
+    if (input.tty) {
+        return { format: "human", source: "default", quiet };
+    }
+    return { format: "json", source: "default", quiet };
+}

package/dist/src/health/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * LAFS Health Check Module
+ *
+ * Provides health check endpoints for monitoring and orchestration
+ */
+export interface HealthCheckConfig {
+    path?: string;
+    checks?: HealthCheckFunction[];
+}
+export type HealthCheckFunction = () => Promise<HealthCheckResult> | HealthCheckResult;
+export interface HealthCheckResult {
+    name: string;
+    status: 'ok' | 'warning' | 'error';
+    message?: string;
+    duration?: number;
+}
+export interface HealthStatus {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    timestamp: string;
+    version: string;
+    uptime: number;
+    checks: HealthCheckResult[];
+}
+/**
+ * Health check middleware for Express applications
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { healthCheck } from '@cleocode/lafs/health';
+ *
+ * const app = express();
+ *
+ * // Basic health check
+ * app.use('/health', healthCheck());
+ *
+ * // Custom health checks
+ * app.use('/health', healthCheck({
+ *   checks: [
+ *     async () => ({
+ *       name: 'database',
+ *       status: await checkDatabase() ? 'ok' : 'error'
+ *     })
+ *   ]
+ * }));
+ * ```
+ */
+export declare function healthCheck(config?: HealthCheckConfig): (req: any, res: any) => Promise<void>;
+/**
+ * Create a database health check
+ *
+ * @example
+ * ```typescript
+ * const dbCheck = createDatabaseHealthCheck({
+ *   checkConnection: async () => await db.ping()
+ * });
+ *
+ * app.use('/health', healthCheck({
+ *   checks: [dbCheck]
+ * }));
+ * ```
+ */
+export declare function createDatabaseHealthCheck(config: {
+    checkConnection: () => Promise<boolean>;
+    name?: string;
+}): HealthCheckFunction;
+/**
+ * Create an external service health check
+ *
+ * @example
+ * ```typescript
+ * const apiCheck = createExternalServiceHealthCheck({
+ *   name: 'payment-api',
+ *   url: 'https://api.payment.com/health',
+ *   timeout: 5000
+ * });
+ * ```
+ */
+export declare function createExternalServiceHealthCheck(config: {
+    name: string;
+    url: string;
+    timeout?: number;
+}): HealthCheckFunction;
+/**
+ * Liveness probe - basic check that service is running
+ *
+ * @example
+ * ```typescript
+ * app.get('/health/live', livenessProbe());
+ * ```
+ */
+export declare function livenessProbe(): (req: any, res: any) => void;
+/**
+ * Readiness probe - check that service is ready to accept traffic
+ *
+ * @example
+ * ```typescript
+ * app.get('/health/ready', readinessProbe({
+ *   checks: [dbCheck, cacheCheck]
+ * }));
+ * ```
+ */
+export declare function readinessProbe(config?: {
+    checks?: HealthCheckFunction[];
+}): (req: any, res: any) => Promise<void>;