@classytic/arc 2.3.0 → 2.4.2

package/dist/utils/index.d.mts

@@ -1,10 +1,201 @@
-import "../elevation-DGo5shaX.mjs";
-import "../interface-BtdYtQUA.mjs";
-import "../types-RLkFVgaw.mjs";
-import { AnyRecord, OpenApiSchemas, ParsedQuery, QueryParserInterface } from "../types/index.mjs";
-import { a as NotFoundError, c as RateLimitError, d as ValidationError, f as createError, i as ForbiddenError, l as ServiceUnavailableError, n as ConflictError, o as OrgAccessDeniedError, p as isArcError, r as ErrorDetails, s as OrgRequiredError, t as ArcError, u as UnauthorizedError } from "../errors-DAWRdiYP.mjs";
+import { G as ParsedQuery, U as OpenApiSchemas, X as QueryParserInterface, l as AnyRecord } from "../interface-DGmPxakH.mjs";
+import { a as NotFoundError, c as RateLimitError, d as ValidationError, f as createError, i as ForbiddenError, l as ServiceUnavailableError, n as ConflictError, o as OrgAccessDeniedError, p as isArcError, r as ErrorDetails, s as OrgRequiredError, t as ArcError, u as UnauthorizedError } from "../errors-CPpvPHT0.mjs";
+import { a as CircuitBreakerStats, c as createCircuitBreakerRegistry, i as CircuitBreakerRegistry, n as CircuitBreakerError, o as CircuitState, r as CircuitBreakerOptions, s as createCircuitBreaker, t as CircuitBreaker } from "../circuitBreaker-JP2GdJ4b.mjs";
 import { FastifyInstance } from "fastify";
 
+//#region src/utils/compensation.d.ts
+/**
+ * Compensating Transaction — In-Process Rollback Primitive
+ *
+ * Runs steps in order. If any step fails, runs compensating actions
+ * for already-completed steps in reverse. Zero dependencies.
+ *
+ * Type-safe: generic context type gives autocomplete across steps.
+ * Discriminated union result: compiler enforces checking success before
+ * accessing failedStep/error.
+ *
+ * For distributed sagas across services, use Temporal, Inngest, or Streamline.
+ *
+ * @example
+ * ```typescript
+ * interface CheckoutCtx {
+ *   orderId: string;
+ *   reservationId?: string;
+ * }
+ *
+ * const result = await withCompensation<CheckoutCtx>('checkout', [
+ *   {
+ *     name: 'reserve',
+ *     execute: async (ctx) => {
+ *       const res = await inventoryService.reserve(ctx.orderId);
+ *       ctx.reservationId = res.id;
+ *       return res;
+ *     },
+ *     compensate: async (ctx) => {
+ *       await inventoryService.release(ctx.reservationId!);
+ *     },
+ *   },
+ *   { name: 'notify', execute: sendEmail, fireAndForget: true },
+ * ], { orderId: 'ord-123' });
+ *
+ * if (result.success) {
+ *   // result.results available, no failedStep
+ * } else {
+ *   // result.failedStep and result.error guaranteed
+ * }
+ * ```
+ */
+/** Step definition with typed context and typed result */
+interface CompensationStep<TCtx = Record<string, unknown>, TResult = unknown> {
+  /** Step name — used in results, logs, and hooks */
+  readonly name: string;
+  /** Execute the step — return value stored in results[name] */
+  readonly execute: (ctx: TCtx) => Promise<TResult>;
+  /** Rollback on failure — receives context and this step's own result */
+  readonly compensate?: (ctx: TCtx, stepResult: TResult) => Promise<void>;
+  /** Fire-and-forget — don't await, don't block, swallow errors, skip in rollback */
+  readonly fireAndForget?: boolean;
+}
+/** Lifecycle hooks for observability — wire to Arc events, metrics, or logging */
+interface CompensationHooks {
+  readonly onStepComplete?: (stepName: string, result: unknown) => void;
+  readonly onStepFailed?: (stepName: string, error: Error) => void;
+  readonly onCompensate?: (stepName: string) => void;
+}
+/** Error from a compensation action that failed during rollback */
+interface CompensationError {
+  readonly step: string;
+  readonly error: string;
+}
+/** Discriminated union — success and failure are mutually exclusive */
+type CompensationResult = {
+  readonly success: true;
+  readonly completedSteps: readonly string[];
+  readonly results: Readonly<Record<string, unknown>>;
+} | {
+  readonly success: false;
+  readonly completedSteps: readonly string[];
+  readonly results: Readonly<Record<string, unknown>>;
+  readonly failedStep: string;
+  readonly error: string;
+  readonly compensationErrors?: readonly CompensationError[];
+};
+/**
+ * Run steps in order with automatic compensation on failure.
+ *
+ * @typeParam TCtx - Context type shared across steps (defaults to Record<string, unknown>)
+ */
+declare function withCompensation<TCtx extends Record<string, unknown> = Record<string, unknown>>(_name: string, steps: readonly CompensationStep<TCtx>[], initialContext?: TCtx, hooks?: CompensationHooks): Promise<CompensationResult>;
+interface CompensationDefinition<TCtx extends Record<string, unknown> = Record<string, unknown>> {
+  readonly name: string;
+  readonly execute: (initialContext?: TCtx, hooks?: CompensationHooks) => Promise<CompensationResult>;
+}
+declare function defineCompensation<TCtx extends Record<string, unknown> = Record<string, unknown>>(name: string, steps: readonly CompensationStep<TCtx>[]): CompensationDefinition<TCtx>;
+//#endregion
+//#region src/utils/queryParser.d.ts
+interface ArcQueryParserOptions {
+  /** Maximum allowed limit value (default: 1000) */
+  maxLimit?: number;
+  /** Default limit for pagination (default: 20) */
+  defaultLimit?: number;
+  /** Maximum regex pattern length (default: 500) */
+  maxRegexLength?: number;
+  /** Maximum search query length (default: 200) */
+  maxSearchLength?: number;
+  /** Maximum filter nesting depth (default: 10) */
+  maxFilterDepth?: number;
+  /**
+   * Whitelist of fields that can be filtered on.
+   * When set, only these fields are accepted as filters — all others are silently dropped.
+   * Also used by MCP to auto-derive filterable fields in tool schemas.
+   */
+  allowedFilterFields?: string[];
+  /**
+   * Whitelist of fields that can be sorted on.
+   * When set, sort fields not in this list are silently dropped.
+   * Also used by MCP to describe available sort options.
+   */
+  allowedSortFields?: string[];
+  /**
+   * Whitelist of filter operators (e.g. ['eq', 'ne', 'gt', 'lt', 'in']).
+   * When set, only these operators are accepted — all others are dropped.
+   * Also used by MCP to enrich list tool descriptions.
+   */
+  allowedOperators?: string[];
+}
+/**
+ * Arc's default query parser
+ *
+ * Converts URL query parameters to a structured query format:
+ * - Pagination: ?page=1&limit=20
+ * - Sorting: ?sort=-createdAt,name (- prefix = descending)
+ * - Filtering: ?status=active&price[gte]=100&price[lte]=500
+ * - Search: ?search=keyword
+ * - Populate: ?populate=author,category
+ * - Field selection: ?select=name,price,status
+ * - Keyset pagination: ?after=cursor_value
+ *
+ * For advanced MongoDB features ($lookup, aggregations), use MongoKit's QueryParser.
+ */
+declare class ArcQueryParser implements QueryParserInterface {
+  private readonly maxLimit;
+  private readonly defaultLimit;
+  private readonly maxRegexLength;
+  private readonly maxSearchLength;
+  private readonly maxFilterDepth;
+  private readonly _allowedFilterFields?;
+  private readonly _allowedSortFields?;
+  private readonly _allowedOperators?;
+  /** Allowed filter fields (used by MCP for auto-derive) */
+  readonly allowedFilterFields?: readonly string[];
+  /** Allowed sort fields (used by MCP for sort descriptions) */
+  readonly allowedSortFields?: readonly string[];
+  /** Allowed operators (used by MCP for operator descriptions) */
+  readonly allowedOperators?: readonly string[];
+  /** Supported filter operators */
+  private readonly operators;
+  constructor(options?: ArcQueryParserOptions);
+  /**
+   * Parse URL query parameters into structured query options
+   */
+  parse(query: Record<string, unknown> | null | undefined): ParsedQuery;
+  private parseNumber;
+  private parseString;
+  /**
+   * Parse populate parameter — handles both simple string and bracket notation.
+   *
+   * Simple: ?populate=author,category → { populate: 'author,category' }
+   * Bracket: ?populate[author][select]=name,email → { populateOptions: [{ path: 'author', select: 'name email' }] }
+   */
+  private parsePopulate;
+  private parseSort;
+  private parseSearch;
+  private parseSelect;
+  /**
+   * Check if a value exceeds the maximum nesting depth.
+   * Prevents filter bombs where deeply nested objects consume excessive memory/CPU.
+   */
+  private exceedsDepth;
+  private parseFilters;
+  private parseFilterValue;
+  private coerceValue;
+  /**
+   * Generate OpenAPI-compatible JSON Schema for query parameters.
+   * Arc's defineResource() auto-detects this method and uses it
+   * to document list endpoint query parameters in OpenAPI/Swagger.
+   */
+  getQuerySchema(): {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+  private sanitizeRegex;
+}
+/**
+ * Create a new ArcQueryParser instance
+ */
+declare function createQueryParser(options?: ArcQueryParserOptions): ArcQueryParser;
+//#endregion
 //#region src/utils/responseSchemas.d.ts
 interface JsonSchema {
   type: string;
@@ -76,7 +267,7 @@ declare const responses: {
   200: (schema: JsonSchema) => {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: JsonSchema;
       };
     };
@@ -84,7 +275,7 @@ declare const responses: {
   201: (schema: JsonSchema) => {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: JsonSchema;
       };
     };
@@ -92,7 +283,7 @@ declare const responses: {
   400: {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: {
           properties: {
             code: {
@@ -132,7 +323,7 @@ declare const responses: {
   401: {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: {
           properties: {
             code: {
@@ -153,7 +344,7 @@ declare const responses: {
   403: {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: {
           properties: {
             code: {
@@ -174,7 +365,7 @@ declare const responses: {
   404: {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: {
           properties: {
             code: {
@@ -195,7 +386,7 @@ declare const responses: {
   409: {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: {
           properties: {
             code: {
@@ -216,7 +407,7 @@ declare const responses: {
   500: {
     description: string;
     content: {
-      'application/json': {
+      "application/json": {
         schema: {
           properties: {
             code: {
@@ -288,6 +479,44 @@ declare function getListQueryParams(): AnyRecord;
  */
 declare function getDefaultCrudSchemas(): Record<string, Record<string, unknown>>;
 //#endregion
+//#region src/utils/schemaConverter.d.ts
+/**
+ * Check if an object is already a plain JSON Schema.
+ * Returns true if it has JSON Schema markers (`type`, `properties`, `$ref`,
+ * `allOf`, `anyOf`, `oneOf`, `items`, `enum`) and does NOT have Zod markers.
+ */
+declare function isJsonSchema(input: unknown): input is Record<string, unknown>;
+/**
+ * Check if an object is a Zod schema (has `_zod` marker from Zod v4).
+ */
+declare function isZodSchema(input: unknown): boolean;
+/**
+ * Convert any schema input to JSON Schema.
+ *
+ * Detection order:
+ * 1. `null`/`undefined` → `undefined`
+ * 2. Already JSON Schema → pass through as-is (zero overhead)
+ * 3. Zod v4 schema → `z.toJSONSchema(schema, { target: 'openapi-3.0' })`
+ * 4. Unrecognized object → return as-is (treat as opaque schema)
+ */
+declare function toJsonSchema(input: unknown): Record<string, unknown> | undefined;
+/**
+ * Convert all schema fields in an OpenApiSchemas object.
+ * JSON Schema values pass through unchanged. Only Zod schemas are converted.
+ */
+declare function convertOpenApiSchemas(schemas: OpenApiSchemas): OpenApiSchemas;
+/**
+ * Convert schema values in a Fastify route schema record.
+ *
+ * Handles `body`, `querystring`, `params`, `headers` (top-level conversion)
+ * and `response` (iterates by status code — each value converted individually).
+ *
+ * JSON Schema values pass through unchanged. Only Zod schemas are converted.
+ *
+ * Used for both additionalRoutes and customSchemas (CRUD overrides).
+ */
+declare function convertRouteSchema(schema: Record<string, unknown>): Record<string, unknown>;
+//#endregion
 //#region src/utils/stateMachine.d.ts
 /**
  * State Machine Utility
@@ -321,7 +550,7 @@ interface StateMachine {
    * Asynchronously check if action can be performed, including guard evaluation.
    * Falls back to simple transition check when no guard is defined.
    */
-  canAsync(action: string, status: string | null | undefined, context?: any): Promise<boolean>;
+  canAsync(action: string, status: string | null | undefined, context?: Record<string, unknown>): Promise<boolean>;
   /**
    * Assert action can be performed, throw error if invalid
    * @param action - Action to perform
@@ -337,7 +566,7 @@ interface StateMachine {
   /**
    * Record a transition
    */
-  recordTransition?(from: string, to: string, action: string, metadata?: any): void;
+  recordTransition?(from: string, to: string, action: string, metadata?: Record<string, unknown>): void;
   /**
    * Clear history
    */
@@ -352,24 +581,17 @@ interface TransitionHistoryEntry {
   to: string;
   action: string;
   timestamp: Date;
-  metadata?: any;
+  metadata?: Record<string, unknown>;
 }
-interface TransitionGuard {
-  (context: {
-    from: string;
-    to: string;
-    action: string;
-    data?: any;
-  }): boolean | Promise<boolean>;
-}
-interface TransitionAction {
-  (context: {
-    from: string;
-    to: string;
-    action: string;
-    data?: any;
-  }): void | Promise<void>;
+/** Context passed to transition guards and actions */
+interface TransitionContext {
+  from: string;
+  to: string;
+  action: string;
+  data?: Record<string, unknown>;
 }
+type TransitionGuard = (context: TransitionContext) => boolean | Promise<boolean>;
+type TransitionAction = (context: TransitionContext) => void | Promise<void>;
 type TransitionConfig = Record<string, string[] | {
   from: string[];
   to?: string;
@@ -410,287 +632,6 @@ declare function createStateMachine(name: string, transitions?: TransitionConfig
   trackHistory?: boolean;
 }): StateMachine;
 //#endregion
-//#region src/utils/circuitBreaker.d.ts
-/**
- * Circuit Breaker Pattern
- *
- * Wraps external service calls with failure protection.
- * Prevents cascading failures by "opening" the circuit when
- * a service is failing, allowing it time to recover.
- *
- * States:
- * - CLOSED: Normal operation, requests pass through
- * - OPEN: Too many failures, all requests fail fast
- * - HALF_OPEN: Testing if service recovered, limited requests
- *
- * @example
- * import { CircuitBreaker } from '@classytic/arc/utils';
- *
- * const paymentBreaker = new CircuitBreaker(async (amount) => {
- *   return await stripe.charges.create({ amount });
- * }, {
- *   failureThreshold: 5,
- *   resetTimeout: 30000,
- *   timeout: 5000,
- * });
- *
- * try {
- *   const result = await paymentBreaker.call(100);
- * } catch (error) {
- *   // Handle failure or circuit open
- * }
- */
-declare const CircuitState: {
-  readonly CLOSED: "CLOSED";
-  readonly OPEN: "OPEN";
-  readonly HALF_OPEN: "HALF_OPEN";
-};
-type CircuitState = (typeof CircuitState)[keyof typeof CircuitState];
-interface CircuitBreakerOptions {
-  /**
-   * Number of failures before opening circuit
-   * @default 5
-   */
-  failureThreshold?: number;
-  /**
-   * Time in ms before attempting to close circuit
-   * @default 60000 (60 seconds)
-   */
-  resetTimeout?: number;
-  /**
-   * Request timeout in ms
-   * @default 10000 (10 seconds)
-   */
-  timeout?: number;
-  /**
-   * Number of successful requests in HALF_OPEN before closing
-   * @default 1
-   */
-  successThreshold?: number;
-  /**
-   * Fallback function when circuit is open
-   */
-  fallback?: (...args: any[]) => Promise<any>;
-  /**
-   * Callback when state changes
-   */
-  onStateChange?: (from: CircuitState, to: CircuitState) => void;
-  /**
-   * Callback on error
-   */
-  onError?: (error: Error) => void;
-  /**
-   * Name for logging/monitoring
-   */
-  name?: string;
-}
-interface CircuitBreakerStats {
-  name?: string;
-  state: CircuitState;
-  failures: number;
-  successes: number;
-  totalCalls: number;
-  openedAt: number | null;
-  lastCallAt: number | null;
-}
-declare class CircuitBreakerError extends Error {
-  state: CircuitState;
-  constructor(message: string, state: CircuitState);
-}
-declare class CircuitBreaker<T extends (...args: any[]) => Promise<any>> {
-  private state;
-  private failures;
-  private successes;
-  private totalCalls;
-  private nextAttempt;
-  private lastCallAt;
-  private openedAt;
-  private readonly failureThreshold;
-  private readonly resetTimeout;
-  private readonly timeout;
-  private readonly successThreshold;
-  private readonly fallback?;
-  private readonly onStateChange?;
-  private readonly onError?;
-  private readonly name;
-  private readonly fn;
-  constructor(fn: T, options?: CircuitBreakerOptions);
-  /**
-   * Call the wrapped function with circuit breaker protection
-   */
-  call(...args: Parameters<T>): Promise<ReturnType<T>>;
-  /**
-   * Execute function with timeout
-   */
-  private executeWithTimeout;
-  /**
-   * Handle successful call
-   */
-  private onSuccess;
-  /**
-   * Handle failed call
-   */
-  private onFailure;
-  /**
-   * Change circuit state
-   */
-  private setState;
-  /**
-   * Manually open the circuit
-   */
-  open(): void;
-  /**
-   * Manually close the circuit
-   */
-  close(): void;
-  /**
-   * Get current statistics
-   */
-  getStats(): CircuitBreakerStats;
-  /**
-   * Get current state
-   */
-  getState(): CircuitState;
-  /**
-   * Check if circuit is open
-   */
-  isOpen(): boolean;
-  /**
-   * Check if circuit is closed
-   */
-  isClosed(): boolean;
-  /**
-   * Reset statistics
-   */
-  reset(): void;
-}
-/**
- * Create a circuit breaker with sensible defaults
- *
- * @example
- * const emailBreaker = createCircuitBreaker(
- *   async (to, subject, body) => sendEmail(to, subject, body),
- *   { name: 'email-service' }
- * );
- */
-declare function createCircuitBreaker<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CircuitBreakerOptions): CircuitBreaker<T>;
-/**
- * Circuit breaker registry for managing multiple breakers
- */
-declare class CircuitBreakerRegistry {
-  private breakers;
-  /**
-   * Register a circuit breaker
-   */
-  register<T extends (...args: any[]) => Promise<any>>(name: string, fn: T, options?: Omit<CircuitBreakerOptions, 'name'>): CircuitBreaker<T>;
-  /**
-   * Get a circuit breaker by name
-   */
-  get(name: string): CircuitBreaker<any> | undefined;
-  /**
-   * Get all breakers
-   */
-  getAll(): Map<string, CircuitBreaker<any>>;
-  /**
-   * Get statistics for all breakers
-   */
-  getAllStats(): Record<string, CircuitBreakerStats>;
-  /**
-   * Reset all breakers
-   */
-  resetAll(): void;
-  /**
-   * Open all breakers
-   */
-  openAll(): void;
-  /**
-   * Close all breakers
-   */
-  closeAll(): void;
-}
-/**
- * Create a new CircuitBreakerRegistry instance.
- * Use this instead of a global singleton — attach to fastify.arc or pass explicitly.
- */
-declare function createCircuitBreakerRegistry(): CircuitBreakerRegistry;
-//#endregion
-//#region src/utils/queryParser.d.ts
-interface ArcQueryParserOptions {
-  /** Maximum allowed limit value (default: 1000) */
-  maxLimit?: number;
-  /** Default limit for pagination (default: 20) */
-  defaultLimit?: number;
-  /** Maximum regex pattern length (default: 500) */
-  maxRegexLength?: number;
-  /** Maximum search query length (default: 200) */
-  maxSearchLength?: number;
-  /** Maximum filter nesting depth (default: 10) */
-  maxFilterDepth?: number;
-}
-/**
- * Arc's default query parser
- *
- * Converts URL query parameters to a structured query format:
- * - Pagination: ?page=1&limit=20
- * - Sorting: ?sort=-createdAt,name (- prefix = descending)
- * - Filtering: ?status=active&price[gte]=100&price[lte]=500
- * - Search: ?search=keyword
- * - Populate: ?populate=author,category
- * - Field selection: ?select=name,price,status
- * - Keyset pagination: ?after=cursor_value
- *
- * For advanced MongoDB features ($lookup, aggregations), use MongoKit's QueryParser.
- */
-declare class ArcQueryParser implements QueryParserInterface {
-  private readonly maxLimit;
-  private readonly defaultLimit;
-  private readonly maxRegexLength;
-  private readonly maxSearchLength;
-  private readonly maxFilterDepth;
-  /** Supported filter operators */
-  private readonly operators;
-  constructor(options?: ArcQueryParserOptions);
-  /**
-   * Parse URL query parameters into structured query options
-   */
-  parse(query: Record<string, unknown> | null | undefined): ParsedQuery;
-  private parseNumber;
-  private parseString;
-  /**
-   * Parse populate parameter — handles both simple string and bracket notation.
-   *
-   * Simple: ?populate=author,category → { populate: 'author,category' }
-   * Bracket: ?populate[author][select]=name,email → { populateOptions: [{ path: 'author', select: 'name email' }] }
-   */
-  private parsePopulate;
-  private parseSort;
-  private parseSearch;
-  private parseSelect;
-  /**
-   * Check if a value exceeds the maximum nesting depth.
-   * Prevents filter bombs where deeply nested objects consume excessive memory/CPU.
-   */
-  private exceedsDepth;
-  private parseFilters;
-  private parseFilterValue;
-  private coerceValue;
-  /**
-   * Generate OpenAPI-compatible JSON Schema for query parameters.
-   * Arc's defineResource() auto-detects this method and uses it
-   * to document list endpoint query parameters in OpenAPI/Swagger.
-   */
-  getQuerySchema(): {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-  };
-  private sanitizeRegex;
-}
-/**
- * Create a new ArcQueryParser instance
- */
-declare function createQueryParser(options?: ArcQueryParserOptions): ArcQueryParser;
-//#endregion
 //#region src/utils/typeGuards.d.ts
 interface EventsDecorator {
   publish: <T>(type: string, payload: T, meta?: Record<string, unknown>) => Promise<void>;
@@ -706,42 +647,4 @@ declare function hasEvents(instance: FastifyInstance): instance is FastifyInstan
   events: EventsDecorator;
 };
 //#endregion
-//#region src/utils/schemaConverter.d.ts
-/**
- * Check if an object is already a plain JSON Schema.
- * Returns true if it has JSON Schema markers (`type`, `properties`, `$ref`,
- * `allOf`, `anyOf`, `oneOf`, `items`, `enum`) and does NOT have Zod markers.
- */
-declare function isJsonSchema(input: unknown): input is Record<string, unknown>;
-/**
- * Check if an object is a Zod schema (has `_zod` marker from Zod v4).
- */
-declare function isZodSchema(input: unknown): boolean;
-/**
- * Convert any schema input to JSON Schema.
- *
- * Detection order:
- * 1. `null`/`undefined` → `undefined`
- * 2. Already JSON Schema → pass through as-is (zero overhead)
- * 3. Zod v4 schema → `z.toJSONSchema(schema, { target: 'openapi-3.0' })`
- * 4. Unrecognized object → return as-is (treat as opaque schema)
- */
-declare function toJsonSchema(input: unknown): Record<string, unknown> | undefined;
-/**
- * Convert all schema fields in an OpenApiSchemas object.
- * JSON Schema values pass through unchanged. Only Zod schemas are converted.
- */
-declare function convertOpenApiSchemas(schemas: OpenApiSchemas): OpenApiSchemas;
-/**
- * Convert schema values in a Fastify route schema record.
- *
- * Handles `body`, `querystring`, `params`, `headers` (top-level conversion)
- * and `response` (iterates by status code — each value converted individually).
- *
- * JSON Schema values pass through unchanged. Only Zod schemas are converted.
- *
- * Used for both additionalRoutes and customSchemas (CRUD overrides).
- */
-declare function convertRouteSchema(schema: Record<string, unknown>): Record<string, unknown>;
-//#endregion
-export { ArcError, ArcQueryParser, type ArcQueryParserOptions, CircuitBreaker, CircuitBreakerError, type CircuitBreakerOptions, CircuitBreakerRegistry, type CircuitBreakerStats, CircuitState, ConflictError, type ErrorDetails, type EventsDecorator, ForbiddenError, type JsonSchema, NotFoundError, OrgAccessDeniedError, OrgRequiredError, RateLimitError, ServiceUnavailableError, type StateMachine, type TransitionConfig, UnauthorizedError, ValidationError, convertOpenApiSchemas, convertRouteSchema, createCircuitBreaker, createCircuitBreakerRegistry, createError, createQueryParser, createStateMachine, deleteResponse, errorResponseSchema, getDefaultCrudSchemas, getListQueryParams, hasEvents, isArcError, isJsonSchema, isZodSchema, itemResponse, itemWrapper, listResponse, messageWrapper, mutationResponse, paginateWrapper, paginationSchema, queryParams, responses, successResponseSchema, toJsonSchema, wrapResponse };
+export { ArcError, ArcQueryParser, type ArcQueryParserOptions, CircuitBreaker, CircuitBreakerError, type CircuitBreakerOptions, CircuitBreakerRegistry, type CircuitBreakerStats, CircuitState, type CompensationDefinition, type CompensationError, type CompensationHooks, type CompensationResult, type CompensationStep, ConflictError, type ErrorDetails, type EventsDecorator, ForbiddenError, type JsonSchema, NotFoundError, OrgAccessDeniedError, OrgRequiredError, RateLimitError, ServiceUnavailableError, type StateMachine, type TransitionConfig, UnauthorizedError, ValidationError, convertOpenApiSchemas, convertRouteSchema, createCircuitBreaker, createCircuitBreakerRegistry, createError, createQueryParser, createStateMachine, defineCompensation, deleteResponse, errorResponseSchema, getDefaultCrudSchemas, getListQueryParams, hasEvents, isArcError, isJsonSchema, isZodSchema, itemResponse, itemWrapper, listResponse, messageWrapper, mutationResponse, paginateWrapper, paginationSchema, queryParams, responses, successResponseSchema, toJsonSchema, withCompensation, wrapResponse };