import type {
  Database,
  Dialect,
  Querier,
  Schema,
  Transaction,
  TransactionalDatabase,
} from '@platform-modules/db';
import { healthCheck, type DbHealthOptions } from '@platform-modules/db/health';
import { withAdvisoryLock } from '@platform-modules/db/locking';
import { createNeonHttpClient } from '@platform-modules/db/postgres/neon-http';
import { createNeonServerlessClient } from '@platform-modules/db/postgres/neon-serverless';
import { createPostgresJsClient } from '@platform-modules/db/postgres/postgres-js';
import { createPgliteClient } from '@platform-modules/db/postgres/pglite';
import {
  createD1Client,
  type D1Binding,
  type D1ClientOptions,
  type DrizzleD1Database,
} from '@platform-modules/db/sqlite/d1';
import {
  createJobRegistry,
  TerminalJobError,
  type DispatchOpts,
  type IdempotencyStore,
  type JobEnvelope,
  type JobRegistry,
  type QueueBatch,
  type QueueMessage,
} from '@platform-modules/jobs';
import {
  consume,
  enqueue,
  resolveQueue,
  type QueueBinding,
  type QueueBindings,
} from '@platform-modules/jobs/cf-queues';
import {
  claim,
  jobsSchema,
  jobsTable,
  markJobCompleted,
  requeueAfterFailure,
  type JobRow,
  type NewJobRow,
} from '@platform-modules/jobs/db-poll';
import {
  dispatchOutboxRow,
  enqueueOutbox,
  insertOutboxRow,
  outboxSchema,
  outboxTable,
  type NewOutboxRow,
  type OutboxRow,
} from '@platform-modules/jobs/outbox';
import {
  JobRunnerDO,
  REARM_DELAY_MS,
  type DurableObjectAlarmContext,
} from '@platform-modules/jobs/do-runner';

type AppSchema = Schema;
declare const db: Database<AppSchema>;
declare const txDb: TransactionalDatabase<AppSchema>;
declare const query: Querier<AppSchema>;
declare const tx: Transaction<AppSchema>;
declare const dialect: Dialect;
declare const d1: DrizzleD1Database<Record<string, never>>;

void [db, txDb, query, tx, dialect, healthCheck, withAdvisoryLock];
void [createNeonHttpClient, createNeonServerlessClient, createPostgresJsClient, createPgliteClient];
void [createD1Client];
void (null as unknown as D1Binding);
void (null as unknown as D1ClientOptions<Record<string, never>>);
void (null as unknown as DrizzleD1Database<Record<string, never>>);
void (null as unknown as DbHealthOptions);
void [createJobRegistry, TerminalJobError];
void (null as unknown as DispatchOpts<unknown>);
void (null as unknown as IdempotencyStore);
void (null as unknown as JobEnvelope);
void (null as unknown as JobRegistry<unknown>);
void (null as unknown as QueueBatch);
void (null as unknown as QueueMessage);
void [consume, enqueue, resolveQueue];
void (null as unknown as QueueBinding);
void (null as unknown as QueueBindings);
void [claim, jobsSchema, jobsTable, markJobCompleted, requeueAfterFailure];
void (null as unknown as JobRow);
void (null as unknown as NewJobRow);
void [dispatchOutboxRow, enqueueOutbox, insertOutboxRow, outboxSchema, outboxTable];
void (null as unknown as NewOutboxRow);
void (null as unknown as OutboxRow);
void [JobRunnerDO, REARM_DELAY_MS];
void (null as unknown as DurableObjectAlarmContext);

// The published D1 seam is SQLite-shaped and cannot be passed to the
// PostgreSQL-shaped advisory-lock helper, even for its runtime sqlite branch.
// @ts-expect-error D1/SQLite queriers are intentionally not root Querier values.
void withAdvisoryLock(d1, 1, async () => undefined, 'sqlite');

// Database lacks interactive transactions; atomic commands must demand this type.
function requiresTransactions(value: TransactionalDatabase<AppSchema>): void {
  void value;
}
// @ts-expect-error A non-transactional Database cannot satisfy an atomic command.
requiresTransactions(db);

export const publicContractCompiles = true;