import {
  OcrivaClient,
  // Error classes
  OcrivaError,
  ApiError,
  AuthenticationError,
  RateLimitError,
  NotFoundError,
  // Types
  type OcrivaClientConfig,
  type PaginationParams,
  type PaginatedResponse,
  type FileType,
  type UploadFileParams,
  type UploadResponse,
  type ResultFormat,
  type ExtractionMode,
  type TemplateDataFile,
  type Template,
  type CreateTemplateParams,
  type UpdateTemplateParams,
  type ListTemplatesParams,
  type Project,
  type ListProjectsParams,
  type ProcessingStatus,
  type ProcessingPriority,
  type ProcessingHistory,
  type ListProcessingHistoryParams,
  type ProcessingHistoryStats,
  type ExportResultParams,
  type BatchStatus,
  type Batch,
  type BatchUploadParams,
  type ListBatchParams,
  type ExportBatchParams,
} from '@ocriva/sdk';

interface OcrivaClientConfig {
  apiKey: string;         // required
  baseUrl?: string;       // default: 'https://api.ocriva.com/v1'
  timeout?: number;       // default: 30000 (ms)
  maxRetries?: number;    // default: 3
}

interface PaginationParams {
  page?: number;   // 1-based page number
  limit?: number;  // items per page
}

interface PaginatedResponse<T> {
  data: T[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    pages: number;
  };
}

type FileType = 'pdf' | 'image' | 'document';

interface UploadFileParams {
  fileName: string;
  fileType: FileType;
  fileSize: string;          // bytes as a string
  mimeType: string;
  projectId: string;
  templateId?: string;
  uploadType?: string;
  metadata?: Record<string, unknown>;
  batchId?: string;
}

interface UploadResponse {
  id: string;
  fileName: string;
  fileUrl: string;
  publicUrl: string;
  filePath: string;
  fileSize: string;
  mimeType: string;
  status: 'uploaded' | 'processing' | 'completed' | 'failed';
  templateId?: string;
  projectId: string;
  uploadedAt: string;
  userId: string;
  organizationId?: string;
  bucketName?: string;
}

type ResultFormat = 'json' | 'text' | 'xml' | 'html' | 'csv' | 'pdf' | 'docx' | 'image';

type ExtractionMode = 'structured' | 'freeText';

interface Template {
  templateId: string;
  name: string;
  description?: string;
  templateSchema?: Record<string, unknown>;
  projectId: string;
  isActive: boolean;
  createdAt: string;
  updatedAt: string;
  resultFormat?: ResultFormat;
  extractionMode?: ExtractionMode;
  instructions?: string;
}

interface CreateTemplateParams {
  name: string;
  description: string;
  templateSchema: Record<string, unknown>;
  projectId: string;
  instructions?: string;
}
 
interface UpdateTemplateParams {
  projectId: string;  // required for scoping
  name?: string;
  description?: string;
  templateSchema?: Record<string, unknown>;
  instructions?: string;
}

interface Project {
  id: string;
  name: string;
  description?: string;
  organizationId: string;
  isActive: boolean;
  createdAt: string;
  updatedAt: string;
}

type ProcessingStatus = 'pending' | 'queued' | 'in_progress' | 'completed' | 'failed';

type ProcessingPriority = 'low' | 'medium' | 'high';

interface ProcessingHistory {
  id: string;
  uploadId: string;
  projectId: string;
  userId: string;
  fileName: string;
  fileUrl: string;
  filePath: string;
  fileSize: string;
  mimeType: string;
  status: ProcessingStatus;
  templateId?: string;
  templateName?: string;
  resultFormat?: ResultFormat;
  priority: ProcessingPriority;
  processingResult?: Record<string, unknown>;
  errorMessage?: string;
  startedAt?: string;
  completedAt?: string;
  estimatedCompletionTime?: string;
  createdAt: string;
  updatedAt: string;
  metadata?: Record<string, unknown>;
  batchId?: string;
}

interface ProcessingHistoryStats {
  total: number;
  pending: number;
  processing: number;
  completed: number;
  failed: number;
}

type BatchStatus = 'uploading' | 'processing' | 'completed' | 'partially_failed' | 'failed';

interface Batch {
  id: string;
  name: string;
  projectId: string;
  organizationId: string;
  userId: string;
  templateId?: string;
  templateName?: string;
  totalFiles: number;
  completedFiles: number;
  failedFiles: number;
  status: BatchStatus;
  uploadIds: string[];
  processingHistoryIds: string[];
  progress: number;   // 0–100
  metadata?: Record<string, unknown>;
  createdAt: string;
  updatedAt: string;
}

interface BatchUploadParams {
  projectId: string;
  templateId?: string;
  name?: string;
  metadata?: Record<string, unknown>;
}

import type { PaginatedResponse, ProcessingHistory, Batch } from '@ocriva/sdk';
 
// Inferred — TypeScript knows this is PaginatedResponse<ProcessingHistory>
const historyPage = await client.processingHistory.list({
  projectId: 'proj_abc123',
});
 
// Explicit annotation (useful when storing the result for later)
let batchPage: PaginatedResponse<Batch>;
batchPage = await client.batch.list({ projectId: 'proj_abc123' });
 
// Access the generic T[] array
const batches: Batch[] = batchPage.data;
console.log(`Total: ${batchPage.pagination.total}`);

import type { ProcessingStatus } from '@ocriva/sdk';
 
function describeStatus(status: ProcessingStatus): string {
  switch (status) {
    case 'pending':
      return 'Waiting to be queued';
    case 'queued':
      return 'In queue for processing';
    case 'in_progress':
      return 'Currently being processed';
    case 'completed':
      return 'Processing finished successfully';
    case 'failed':
      return 'Processing failed';
    default: {
      // TypeScript will error here if a new status is added to the SDK
      // but not handled in this switch statement
      const _exhaustive: never = status;
      return _exhaustive;
    }
  }
}