import { i as ContentItem } from "./types-C4ZXxSAE.mjs";
import { t as Database } from "./types-BCOU_CXE.mjs";
import { Kysely } from "kysely";
import { z } from "zod";

//#region src/api/types.d.ts
/**
 * List response with cursor pagination
 */
interface ListResponse<T> {
  items: T[];
  nextCursor?: string;
  /**
   * Total number of rows matching the filters, ignoring pagination. Used
   * by the admin to render a stable pagination denominator. Optional so
   * callers that don't surface a row count don't pay for the extra query.
   */
  total?: number;
}
/**
 * Content API responses
 */
interface ContentListResponse extends ListResponse<ContentItem> {}
interface ContentResponse {
  item: ContentItem;
  /** Opaque revision token for optimistic concurrency */
  _rev?: string;
}
/**
 * Manifest API response
 */
interface ManifestResponse {
  version: string;
  hash: string;
  collections: Record<string, {
    label: string;
    labelSingular: string;
    supports: string[];
    routable?: boolean;
    fields: Record<string, FieldDescriptor>;
  }>;
  plugins: Record<string, {
    adminPages?: Array<{
      path: string;
      component: string;
    }>;
    widgets?: string[];
  }>;
}
interface FieldDescriptor {
  kind: string;
  label?: string;
  required?: boolean;
  /**
   * For `select` / `multiSelect`: the list of enum choices.
   * For `json` fields driven by a plugin `widget`: arbitrary widget config.
   */
  options?: Array<{
    value: string;
    label: string;
  }> | Record<string, unknown>;
}
/**
 * Discriminated union for handler results.
 *
 * Handlers return `ApiResult<T>` -- either `{ success: true, data: T }` or
 * `{ success: false, error: { code, message } }`. The `success` literal
 * enables TypeScript narrowing on `.data`.
 *
 * The generic `E` parameter defaults to `ErrorCode` but can be narrowed to
 * `OAuthErrorCode` for OAuth token-endpoint handlers.
 *
 * Use `unwrapResult()` from `error.ts` to convert to an HTTP Response.
 */
type ApiResult<T, E extends string = string> = {
  success: true;
  data: T;
} | {
  success: false;
  error: {
    code: E;
    message: string;
    details?: Record<string, unknown>;
  };
};
/**
 * API request context
 */
interface ApiContext {
  userId?: string;
  userRole?: string;
}
//#endregion
//#region src/api/error.d.ts
/**
 * Create a standardized error response.
 *
 * Always returns `{ success: false, error: { code, message } }` with correct
 * Content-Type. Use this for all error responses in API routes.
 */
declare function apiError(code: string, message: string, status: number, details?: Record<string, unknown>): Response;
/**
 * Create a standardized success response.
 *
 * Always returns `{ success: true, data: T }` with correct status code.
 * Use this for all success responses in API routes.
 */
declare function apiSuccess<T>(data: T, status?: number): Response;
/**
 * Handle an unknown error in a catch block.
 *
 * - Logs the full error server-side
 * - Returns a generic message to the client (never leaks error.message)
 * - Use `fallbackMessage` for the public-facing message
 * - Use `fallbackCode` for the error code
 */
declare function handleError(error: unknown, fallbackMessage: string, fallbackCode: string): Response;
//#endregion
//#region src/api/parse.d.ts
/**
 * Result of parsing: either the validated data or an error Response.
 * Routes should check `if (result instanceof Response) return result;`
 */
type ParseResult<T> = T | Response;
/**
 * Parse and validate a JSON request body against a Zod schema.
 *
 * Returns the validated data on success, or a 400 Response on failure.
 * Replaces all `(await request.json()) as T` casts.
 */
declare function parseBody<T extends z.ZodType>(request: Request, schema: T): Promise<ParseResult<z.infer<T>>>;
/**
 * Parse and validate URL search params against a Zod schema.
 *
 * Converts searchParams to a plain object before validation.
 * Zod coercion handles string -> number/boolean conversion.
 * Replaces manual `url.searchParams.get()` + `parseInt()` patterns.
 */
declare function parseQuery<T extends z.ZodType>(url: URL, schema: T): ParseResult<z.infer<T>>;
/**
 * Type guard to check if a ParseResult is an error Response.
 * Usage: `if (isParseError(result)) return result;`
 */
declare function isParseError<T>(result: ParseResult<T>): result is Response;
//#endregion
//#region src/database/repositories/options.d.ts
/**
 * Options repository for key-value settings storage
 *
 * Used for site settings, plugin configuration, and other arbitrary key-value data.
 * Values are stored as JSON for flexibility.
 */
declare class OptionsRepository {
  private db;
  constructor(db: Kysely<Database>);
  /**
   * Get an option value
   */
  get<T = unknown>(name: string): Promise<T | null>;
  /**
   * Get an option value with a default
   */
  getOrDefault<T>(name: string, defaultValue: T): Promise<T>;
  /**
   * Set an option value (creates or updates)
   */
  set<T = unknown>(name: string, value: T): Promise<void>;
  /**
   * Set an option value only if no row with that name exists. Atomic at the
   * database level via INSERT ... ON CONFLICT DO NOTHING, so concurrent
   * callers can't race past the check.
   *
   * Returns true when the row was inserted, false when a row already
   * existed (regardless of its value — even an empty string or null).
   */
  setIfAbsent<T = unknown>(name: string, value: T): Promise<boolean>;
  /**
   * Delete an option
   */
  delete(name: string): Promise<boolean>;
  /**
   * Check if an option exists
   */
  exists(name: string): Promise<boolean>;
  /**
   * Get multiple options at once
   */
  getMany<T = unknown>(names: string[]): Promise<Map<string, T>>;
  /**
   * Set multiple options at once
   */
  setMany<T = unknown>(options: Record<string, T>): Promise<void>;
  /**
   * Get all options (use sparingly)
   */
  getAll(): Promise<Map<string, unknown>>;
  /**
   * Get all options matching a prefix
   */
  getByPrefix<T = unknown>(prefix: string): Promise<Map<string, T>>;
  /**
   * Delete all options matching a prefix
   */
  deleteByPrefix(prefix: string): Promise<number>;
}
//#endregion
export { parseQuery as a, handleError as c, ContentListResponse as d, ContentResponse as f, ManifestResponse as h, parseBody as i, ApiContext as l, ListResponse as m, ParseResult as n, apiError as o, FieldDescriptor as p, isParseError as r, apiSuccess as s, OptionsRepository as t, ApiResult as u };
//# sourceMappingURL=options-B5K8QEV1.d.mts.map