// Type declarations for @aitizer/js (https://api.aitizer.com/sdk/aitizer.js)

export interface AitizerClientOptions {
  headers?: Record<string, string>;
  appSession?: string | null;
  flatten?: boolean;
  fetch?: typeof fetch;
  /** Silence the warning about using a REST token inside a browser. */
  dangerouslyAllowBrowser?: boolean;
}

export interface AitizerResult<T = any> {
  data: T | null;
  error: AitizerError | null;
  count: number | null;
  status: number;
}

export type Row = { id: number; created_at: string; updated_at: string } & Record<string, any>;
export interface RawRecord { id: number; fields: Record<string, any>; created_at: string; updated_at: string }
export interface TableInfo { id: number; name: string; icon: string; created_at: string; updated_at: string }
export interface ColumnInfo { id: number; name: string; type: string; required: boolean; position: number; options?: Array<{ id: string; label: string; color?: string }>; formula?: string }

export class AitizerError extends Error {
  status: number;
  code?: string;
  details?: unknown;
}

export type FilterOp = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs';

export class QueryBuilder<T = Row> implements PromiseLike<AitizerResult<T[]>> {
  select(columns?: string, options?: { count?: 'exact' }): this;
  insert(values: Record<string, any> | Record<string, any>[]): this;
  upsert(values: Record<string, any> | Record<string, any>[]): this;
  update(values: Record<string, any>): this;
  delete(): this;

  eq(field: string, value: any): this;
  neq(field: string, value: any): this;
  gt(field: string, value: any): this;
  gte(field: string, value: any): this;
  lt(field: string, value: any): this;
  lte(field: string, value: any): this;
  like(field: string, pattern: string): this;
  ilike(field: string, pattern: string): this;
  is(field: string, value: null | boolean): this;
  in(field: string, values: any[]): this;
  contains(field: string, values: any | any[]): this;
  not(field: string, op: FilterOp, value: any): this;
  filter(field: string, op: string, value: any): this;
  search(field: string, term: string): this;

  order(field: string, options?: { ascending?: boolean }): this;
  limit(n: number): this;
  range(from: number, to: number): this;
  single(): QueryBuilder<T> & PromiseLike<AitizerResult<T>>;
  maybeSingle(): QueryBuilder<T> & PromiseLike<AitizerResult<T | null>>;

  then<R1 = AitizerResult<T[]>, R2 = never>(
    onfulfilled?: ((value: AitizerResult<T[]>) => R1 | PromiseLike<R1>) | null,
    onrejected?: ((reason: any) => R2 | PromiseLike<R2>) | null,
  ): PromiseLike<R1 | R2>;
}

export interface AppAuth {
  signInWithPassword(credentials: { email: string; password: string }): Promise<{ data: any; error: AitizerError | null }>;
  signUp(credentials: { email: string; password: string; [k: string]: any }): Promise<{ data: any; error: AitizerError | null }>;
  getUser(): Promise<{ data: any; error: AitizerError | null }>;
  signOut(): { error: null };
}

export class AitizerClient {
  constructor(url: string, token?: string | null, options?: AitizerClientOptions);
  from<T = Row>(table: string | number): QueryBuilder<T>;
  sql<T = Row>(query: string): Promise<AitizerResult<T[]>>;
  tables(): Promise<AitizerResult<TableInfo[]>>;
  columns(table: string | number): Promise<AitizerResult<ColumnInfo[]>>;
  compute(table: string | number, recordId: number, columnName: string): Promise<AitizerResult<any>>;
  setSession(session: string | null): void;
  clearCache(): void;
  auth: AppAuth;
}

export function createClient(url: string, token?: string | null, options?: AitizerClientOptions): AitizerClient;
export default createClient;