/**
 * @fileoverview API types and error handling.
 *
 * Defines the standardized API response envelope (ApiResponse), error codes,
 * hook event types from Claude Code's hooks system, and utility functions
 * for error message extraction. Used by all route modules in `src/web/routes/`.
 *
 * Key exports:
 * - ApiResponse<T> — discriminated union envelope (success with data or error with code)
 * - ApiErrorCode — enum of standard error codes with user-friendly messages
 * - HookEventType — union of Claude Code hook event names (idle_prompt, stop, etc.)
 * - createErrorResponse() — factory for consistent error responses
 * - getErrorMessage() — safe extraction from unknown catch values
 * - CaseInfo, QuickStartResponse — case folder metadata types
 *
 * No dependencies on other domain modules. Consumed by all route modules
 * and validated via Zod schemas in `src/web/schemas.ts`.
 */
/**
 * Standard error codes for API responses
 */
export var ApiErrorCode;
(function (ApiErrorCode) {
    /** Resource not found */
    ApiErrorCode["NOT_FOUND"] = "NOT_FOUND";
    /** Invalid input provided */
    ApiErrorCode["INVALID_INPUT"] = "INVALID_INPUT";
    /** Authentication required or failed */
    ApiErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
    /** Session is currently busy */
    ApiErrorCode["SESSION_BUSY"] = "SESSION_BUSY";
    /** Request conflicts with current state (e.g. already running) */
    ApiErrorCode["CONFLICT"] = "CONFLICT";
    /** Resource already exists */
    ApiErrorCode["ALREADY_EXISTS"] = "ALREADY_EXISTS";
    /** Too many requests / rate limited */
    ApiErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
    /** Operation could not be completed (well-formed but unprocessable) */
    ApiErrorCode["OPERATION_FAILED"] = "OPERATION_FAILED";
    /** Internal server error */
    ApiErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
})(ApiErrorCode || (ApiErrorCode = {}));
/**
 * User-friendly error messages for each error code
 */
const ErrorMessages = {
    [ApiErrorCode.NOT_FOUND]: 'The requested resource was not found',
    [ApiErrorCode.INVALID_INPUT]: 'Invalid input provided',
    [ApiErrorCode.UNAUTHORIZED]: 'Authentication required',
    [ApiErrorCode.SESSION_BUSY]: 'Session is currently busy',
    [ApiErrorCode.CONFLICT]: 'Request conflicts with the current state',
    [ApiErrorCode.ALREADY_EXISTS]: 'Resource already exists',
    [ApiErrorCode.RATE_LIMITED]: 'Too many requests',
    [ApiErrorCode.OPERATION_FAILED]: 'The operation failed',
    [ApiErrorCode.INTERNAL_ERROR]: 'An internal error occurred',
};
/**
 * Maps each API error code to its HTTP status. Single source of truth for the
 * stable HTTP contract (see docs/api-reference.md). Applied centrally so every
 * error response carries a conventional 4xx/5xx status, not 200.
 */
const ErrorStatus = {
    [ApiErrorCode.INVALID_INPUT]: 400,
    [ApiErrorCode.UNAUTHORIZED]: 401,
    [ApiErrorCode.NOT_FOUND]: 404,
    [ApiErrorCode.SESSION_BUSY]: 409,
    [ApiErrorCode.CONFLICT]: 409,
    [ApiErrorCode.ALREADY_EXISTS]: 409,
    [ApiErrorCode.OPERATION_FAILED]: 422,
    [ApiErrorCode.RATE_LIMITED]: 429,
    [ApiErrorCode.INTERNAL_ERROR]: 500,
};
/** HTTP status for an API error code (defaults to 400 for unknown codes). */
export function httpStatusForErrorCode(code) {
    return ErrorStatus[code] ?? 400;
}
/**
 * Creates a standardized error response
 * @param code Error code
 * @param details Optional detailed error message
 * @returns Formatted error response
 */
export function createErrorResponse(code, details) {
    return {
        success: false,
        error: details || ErrorMessages[code],
        errorCode: code,
    };
}
// ========== Error Handling Utilities ==========
/**
 * Type guard to check if a value is an Error instance
 * @param value The value to check
 * @returns True if the value is an Error instance
 */
function isError(value) {
    return value instanceof Error;
}
/**
 * Safely extracts an error message from an unknown caught value.
 * Handles the TypeScript 4.4+ unknown error type in catch blocks.
 *
 * @param error The caught error (type unknown in strict mode)
 * @returns A string error message
 *
 * @example
 * ```typescript
 * try {
 *   await riskyOperation();
 * } catch (err) {
 *   console.error('Failed:', getErrorMessage(err));
 * }
 * ```
 */
export function getErrorMessage(error) {
    if (isError(error)) {
        return error.message;
    }
    if (typeof error === 'string') {
        return error;
    }
    if (error && typeof error === 'object' && 'message' in error) {
        return String(error.message);
    }
    return 'An unknown error occurred';
}
//# sourceMappingURL=api.js.map