import type { IndexPaginator } from './auto-crud';
import type { ModelCreateData, ModelRow } from './model-types';
/** The listing envelope: rows, the flat paginator, and the deprecated `meta`. */
export declare interface ApiIndexResponse<TRow> extends IndexPaginator {
  data: TRow[]
  meta: Record<string, unknown>
}
/** The single-row envelope, used by show, store and update alike. */
export declare interface ApiItemResponse<TRow> {
  data: TRow
}
/** The definition behind a model, whether it was passed bare or via `defineModel`. */
declare type Definition<M> = M extends { attributes: unknown } ? M : never;
declare type ApiTrait<M> = Definition<M> extends { traits?: { useApi?: infer A } } ? A : never;
/** `useApi: { uri: 'products' }` → `'products'`, else the table, else name + "s". */
declare type ApiUri<M> = ApiTrait<M> extends { uri: infer U extends string }
    ? U
    : (Definition<M> extends { table: infer T extends string }
        ? T
        : (Definition<M> extends { name: infer N extends string } ? `${Lowercase<N>}s` : never));
declare type ApiPrefix<M> = ApiTrait<M> extends { prefix: infer P extends string } ? `${P}/` : '';
/** `/api/{prefix/}{uri}` — the same shape `apiBasePath()` builds. */
export type ApiBasePathFor<M> = `/api/${ApiPrefix<M>}${ApiUri<M>}`;
declare type DefaultRoutes = 'index' | 'show' | 'store' | 'update' | 'destroy';
/** Which of the CRUD verbs this model publishes. */
declare type EnabledRoutes<M> = ApiTrait<M> extends { routes: infer R extends readonly string[] }
    ? R[number]
    : DefaultRoutes;
declare type Attributes<M> = Definition<M> extends { attributes: infer A } ? A : never;
/** Attributes flagged `hidden: true`, which never appear in a response. */
declare type HiddenKeys<M> = {
  [K in keyof Attributes<M>]: Attributes<M>[K] extends { hidden: true } ? K : never
}[keyof Attributes<M>];
/** A row as the generated endpoints actually return it: hidden fields removed. */
export type ApiRow<M> = Omit<ModelRow<M>, Extract<HiddenKeys<M>, keyof ModelRow<M>>>;
/** What a write accepts: fillable fields, minus anything hidden. */
export type ApiWriteData<M> = Omit<ModelCreateData<M>, Extract<HiddenKeys<M>, keyof ModelCreateData<M>>>;
declare type Params<TId extends string = 'id'> = { [K in TId]: string }
declare type IndexRoute<M, TBase extends string> = 'index' extends EnabledRoutes<M>
    ? { [K in `GET ${TBase}`]: { input: Record<string, never>, output: ApiIndexResponse<ApiRow<M>>, params: Record<string, never> } }
    : Record<string, never>;
declare type ShowRoute<M, TBase extends string> = 'show' extends EnabledRoutes<M>
    ? { [K in `GET ${TBase}/{id}`]: { input: Record<string, never>, output: ApiItemResponse<ApiRow<M>>, params: Params } }
    : Record<string, never>;
declare type StoreRoute<M, TBase extends string> = 'store' extends EnabledRoutes<M>
    ? { [K in `POST ${TBase}`]: { input: ApiWriteData<M>, output: ApiItemResponse<ApiRow<M>>, params: Record<string, never> } }
    : Record<string, never>;
declare type UpdateRoute<M, TBase extends string> = 'update' extends EnabledRoutes<M>
    ? {
        [K in `PUT ${TBase}/{id}` | `PATCH ${TBase}/{id}`]: {
          input: ApiWriteData<M>
          output: ApiItemResponse<ApiRow<M>>
          params: Params
        }
      }
    : Record<string, never>;
declare type DestroyRoute<M, TBase extends string> = 'destroy' extends EnabledRoutes<M>
    ? {
        [K in `DELETE ${TBase}/{id}`]: { input: Record<string, never>, output: undefined, params: Params }
      } & {
        [K in `POST ${TBase}/bulk-delete`]: {
          input: { ids: Array<number | string> }
          output: { message: string }
          params: Record<string, never>
        }
      }
    : Record<string, never>;
/**
 * Every endpoint `useApi` publishes for this model, as a route map the typed
 * client understands.
 *
 * Intersect several of them - one per model - to describe a whole generated
 * API, and intersect that with `RoutesOf<typeof api>` to describe an app that
 * has both generated and hand-written routes.
 */
export type ApiRoutesFor<M> = ApiBasePathFor<M> extends infer TBase extends string
    ? IndexRoute<M, TBase>
    & ShowRoute<M, TBase>
    & StoreRoute<M, TBase>
    & UpdateRoute<M, TBase>
    & DestroyRoute<M, TBase>
    : never;