/** Programmatic datalake client API shipped with @ariestools/cli (bundled). */

export interface AuthTokenRequest {
  audience: string
}
export type AuthTokenSupplier = (request: AuthTokenRequest) => Promise<string>
export type AuthTokenSource = string | AuthTokenSupplier
export type PayloadsAuthTokenSource = AuthTokenSource

export type DatalakeRole = 'viewer' | 'runner'
export type DatalakePrincipal = string
export type DatalakeTier = 'small' | 'medium' | 'large' | 'archive'
export type DatalakeRegion = 'us-west-2' | 'us-east-1' | 'eu-west-1'
export type DatalakeStatus =
  | 'pending'
  | 'provisioning'
  | 'ready'
  | 'resizing'
  | 'deprovisioning'
  | 'deleted'
  | 'error'

export interface RateLimitOverrides {
  anonymousPerMinute?: number
  authenticatedPerMinute?: number
  burstFactor?: number
}

export interface DatalakeConfig {
  allowedSchemas?: string[]
  disallowedSchemas?: string[]
  iops?: number
  rateLimits?: RateLimitOverrides
  region?: DatalakeRegion
  retentionDays?: number | null
  sizeBytes?: number
  tier: DatalakeTier
  /** @deprecated No-op; archivist recomputes hashes trustlessly. */
  verifyHashes?: boolean
}

export interface AclEntry {
  grantedAt: string
  grantedBy?: string
  principal: DatalakePrincipal
  role: DatalakeRole
}

export interface DatalakeUsage {
  bytesStored: number
  bytesStoredLimit: number
  payloadCount: number
  readsLast24h: number
  writesLast24h: number
}

export interface DatalakeDescriptor {
  acl: AclEntry[]
  config: DatalakeConfig
  createdAt: string
  errorMessage?: string
  id: string
  name: string
  ownerId: string
  status: DatalakeStatus
  updatedAt: string
  url?: string
  usage?: DatalakeUsage
}

export interface DatalakeToken {
  datalakeId: string
  expiresAt: string
  role: DatalakeRole
  token: string
  url: string
}

export interface CreateDatalakeRequest {
  config: DatalakeConfig
  name: string
}

export interface GrantRequest {
  datalakeId: string
  principal: DatalakePrincipal
  role: DatalakeRole
}

export interface RevokeRequest {
  datalakeId: string
  principal: DatalakePrincipal
}

export interface TokenRequest {
  datalakeId: string
  role: DatalakeRole
  ttlSeconds?: number
}

export interface WalletJwtCredentials {
  controlAudience?: string
  offset?: string
  ttlSeconds?: number
}

export interface StoredCredentials {
  authToken?: string
  baseUrl: string
  expiresAt?: string
  refreshToken?: string
  userId?: string
  walletJwt?: WalletJwtCredentials
}

export interface CreateDatalakeClientOptions {
  authToken?: AuthTokenSource
  baseUrl?: string
  driver?: 'local' | 'rest'
}

export interface RestDatalakeClientOptions {
  authToken: AuthTokenSource
  audience?: string
  baseUrl: string
  fetchImpl?: typeof fetch
}

export interface RestPayloadsClientOptions {
  authToken: PayloadsAuthTokenSource
  baseUrl: string
  datalakeId: string
  fetchImpl?: typeof fetch
}

export interface DatalakeInsertSummary {
  duplicates: number
  rejected: string[]
}

/** Result of PayloadsClient.insert — matches RestPayloadsClient runtime. */
export interface InsertPayloadsResult {
  inserted: unknown[]
  summary: DatalakeInsertSummary
}

export interface NextPayloadsResult {
  nextCursor?: string
  payloads: unknown[]
}

export interface DatalakeUsageReport {
  datalakeId: string
  payloadCount: number
  rateLimits?: {
    anonymous?: { limit: number; remaining: number }
    authenticated?: { limit: number; remaining: number }
  }
}

export type DatalakeDevServerStatus =
  | 'healthy'
  | 'degraded'
  | 'unresponsive'
  | 'stale'
  | 'stopped'

export type DatalakeDevServerExitCode = 0 | 2 | 3

export interface DatalakeDevServerEndpointReport {
  healthy: boolean
  url: string
}

export interface DatalakeDevServerReport {
  schemaVersion: 1
  status: DatalakeDevServerStatus
  exitCode: DatalakeDevServerExitCode
  process: {
    running: boolean
    pid: number | null
    startedAt: string | null
  }
  endpoints: {
    control: DatalakeDevServerEndpointReport | null
    plane: DatalakeDevServerEndpointReport | null
  }
}

export interface InspectDatalakeDevServerOptions {
  timeoutMs?: number
}

export interface PayloadsClient {
  clear(): Promise<{ removed: number }>
  delete(hash: string): Promise<void>
  get(hash: string): Promise<unknown>
  getMany(hashes: string[]): Promise<unknown[]>
  insert(payloads: unknown[]): Promise<InsertPayloadsResult>
  next(options?: {
    cursor?: string
    limit?: number
    order?: 'asc' | 'desc'
    schemas?: string[]
  }): Promise<NextPayloadsResult>
  usage(): Promise<DatalakeUsageReport>
}

export interface DatalakeClient {
  create(request: CreateDatalakeRequest): Promise<DatalakeDescriptor>
  describe(idOrName: string): Promise<DatalakeDescriptor>
  destroy(idOrName: string): Promise<void>
  grant(request: GrantRequest): Promise<DatalakeDescriptor>
  list(): Promise<DatalakeDescriptor[]>
  mintToken(request: TokenRequest): Promise<DatalakeToken>
  revoke(request: RevokeRequest): Promise<DatalakeDescriptor>
}

export declare function createDatalakeClient(options?: CreateDatalakeClientOptions): DatalakeClient
export declare function inspectDatalakeDevServer(
  options?: InspectDatalakeDevServerOptions,
): Promise<DatalakeDevServerReport>
export declare class LocalDatalakeClient implements DatalakeClient {
  create(request: CreateDatalakeRequest): Promise<DatalakeDescriptor>
  describe(idOrName: string): Promise<DatalakeDescriptor>
  destroy(idOrName: string): Promise<void>
  grant(request: GrantRequest): Promise<DatalakeDescriptor>
  list(): Promise<DatalakeDescriptor[]>
  mintToken(request: TokenRequest): Promise<DatalakeToken>
  revoke(request: RevokeRequest): Promise<DatalakeDescriptor>
}
export declare class RestDatalakeClient implements DatalakeClient {
  constructor(options: RestDatalakeClientOptions)
  create(request: CreateDatalakeRequest): Promise<DatalakeDescriptor>
  describe(idOrName: string): Promise<DatalakeDescriptor>
  destroy(idOrName: string): Promise<void>
  grant(request: GrantRequest): Promise<DatalakeDescriptor>
  list(): Promise<DatalakeDescriptor[]>
  mintToken(request: TokenRequest): Promise<DatalakeToken>
  revoke(request: RevokeRequest): Promise<DatalakeDescriptor>
}
export declare class RestPayloadsClient implements PayloadsClient {
  constructor(options: RestPayloadsClientOptions)
  clear(): Promise<{ removed: number }>
  delete(hash: string): Promise<void>
  get(hash: string): Promise<unknown>
  getMany(hashes: string[]): Promise<unknown[]>
  insert(payloads: unknown[]): Promise<InsertPayloadsResult>
  next(options?: {
    cursor?: string
    limit?: number
    order?: 'asc' | 'desc'
    schemas?: string[]
  }): Promise<NextPayloadsResult>
  usage(): Promise<DatalakeUsageReport>
}

export declare function loadCredentials(): StoredCredentials | undefined
export declare function saveCredentials(credentials: StoredCredentials): void
export declare function clearCredentials(): void
export declare function getCredentialsLocation(): string
export declare function getDefaultDatalake(): string | undefined
export declare function setDefaultDatalake(name: string, id?: string): void
export declare function clearDefaultDatalake(): void