async file(
  file: File | Blob | Uint8Array,
  params: UploadFileParams,
): Promise<UploadResponse>

import { OcrivaClient } from '@ocriva/sdk';
 
const client = new OcrivaClient({ apiKey: process.env.OCRIVA_API_KEY! });
 
async function handleFileInput(file: File) {
  const result = await client.upload.file(file, {
    fileName: file.name,
    fileType: 'pdf',
    fileSize: String(file.size),
    mimeType: file.type,
    projectId: 'proj_abc123',
  });
 
  console.log('Upload ID:', result.id);
  console.log('Status:', result.status);
}

import { readFileSync } from 'node:fs';
 
const buffer = readFileSync('./receipt.jpg');
 
const result = await client.upload.file(buffer, {
  fileName: 'receipt.jpg',
  fileType: 'image',
  fileSize: String(buffer.byteLength),
  mimeType: 'image/jpeg',
  projectId: 'proj_abc123',
  templateId: 'tmpl_xyz789',
});

const response = await fetch('https://example.com/document.pdf');
const blob = await response.blob();
 
const result = await client.upload.file(blob, {
  fileName: 'document.pdf',
  fileType: 'pdf',
  fileSize: String(blob.size),
  mimeType: 'application/pdf',
  projectId: 'proj_abc123',
  metadata: { source: 'crm', customerId: 'cust_999' },
});

{
  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;
}

async list(params?: ListTemplatesParams): Promise<Template[]>

// List all templates
const templates = await client.templates.list();
 
// Filter by project with pagination
const page1 = await client.templates.list({
  projectId: 'proj_abc123',
  page: 1,
  limit: 20,
});
 
console.log(`Found ${page1.length} templates`);

async create(params: CreateTemplateParams): Promise<Template>

const template = await client.templates.create({
  name: 'Invoice Template',
  description: 'Extracts line items, totals, and vendor information from invoices',
  projectId: 'proj_abc123',
  templateSchema: {
    type: 'object',
    properties: {
      invoiceNumber: { type: 'string', description: 'Invoice number' },
      vendorName: { type: 'string', description: 'Vendor or supplier name' },
      totalAmount: { type: 'number', description: 'Total invoice amount' },
      dueDate: { type: 'string', description: 'Payment due date (YYYY-MM-DD)' },
      lineItems: {
        type: 'array',
        items: {
          type: 'object',
          properties: {
            description: { type: 'string' },
            quantity: { type: 'number' },
            unitPrice: { type: 'number' },
          },
        },
      },
    },
  },
  instructions: 'Extract all monetary values as numbers without currency symbols.',
});
 
console.log('Template ID:', template.templateId);

async update(id: string, params: UpdateTemplateParams): Promise<Template>

// Partial update — only change the instructions
const updated = await client.templates.update('tmpl_xyz789', {
  projectId: 'proj_abc123',
  instructions: 'Always return amounts in USD. If currency is not USD, convert it.',
});

async delete(id: string): Promise<void>

await client.templates.delete('tmpl_xyz789');
// Returns void — no response body

async uploadFile(templateId: string, file: File | Blob): Promise<Template>

import { readFileSync } from 'node:fs';
 
// Attach a reference schema as a Markdown file
const mdContent = readFileSync('./field-guide.md');
const blob = new Blob([mdContent], { type: 'text/markdown' });
 
const updatedTemplate = await client.templates.uploadFile('tmpl_xyz789', blob);
console.log('Attached files:', updatedTemplate.templateId);

async deleteFile(templateId: string, fileId: string): Promise<Template>

const updatedTemplate = await client.templates.deleteFile(
  'tmpl_xyz789',
  'file_abc456',
);

async list(params?: ListProjectsParams): Promise<Project[]>

// List all accessible projects
const projects = await client.projects.list();
 
for (const project of projects) {
  console.log(`${project.id}: ${project.name} (active: ${project.isActive})`);
}
 
// Scope to one project using an organization token
const filtered = await client.projects.list({ projectId: 'proj_abc123' });

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

async list(
  params?: ListProcessingHistoryParams,
): Promise<PaginatedResponse<ProcessingHistory>>

// List completed records for a project
const result = await client.processingHistory.list({
  projectId: 'proj_abc123',
  status: 'completed',
  page: 1,
  limit: 50,
});
 
console.log(`Page ${result.pagination.page} of ${result.pagination.pages}`);
console.log(`Total records: ${result.pagination.total}`);
 
for (const record of result.data) {
  console.log(`${record.id}: ${record.fileName} — ${record.status}`);
}
 
// Filter by date range
const recent = await client.processingHistory.list({
  projectId: 'proj_abc123',
  fromDate: '2026-03-01',
  toDate: '2026-03-31',
});
 
// Filter by template
const byTemplate = await client.processingHistory.list({
  projectId: 'proj_abc123',
  templateId: 'tmpl_xyz789',
  status: 'failed',
});

async get(id: string, projectId?: string): Promise<ProcessingHistory>

const record = await client.processingHistory.get(
  'hist_abc123',
  'proj_abc123', // required for organization tokens
);
 
console.log('Status:', record.status);
console.log('Result:', record.processingResult);

async getResult(id: string, params?: ExportResultParams): Promise<Blob>

// Download as JSON and parse
const blob = await client.processingHistory.getResult('hist_abc123', {
  format: 'json',
  projectId: 'proj_abc123',
});
const data = JSON.parse(await blob.text());
console.log(data);
 
// Download as PDF and save to disk (Node.js)
import { writeFileSync } from 'node:fs';
 
const pdfBlob = await client.processingHistory.getResult('hist_abc123', {
  format: 'pdf',
  projectId: 'proj_abc123',
});
const arrayBuffer = await pdfBlob.arrayBuffer();
writeFileSync('./result.pdf', Buffer.from(arrayBuffer));
 
// Download as CSV
const csvBlob = await client.processingHistory.getResult('hist_abc123', {
  format: 'csv',
  projectId: 'proj_abc123',
});
const csv = await csvBlob.text();
console.log(csv);

async stats(params: { projectId: string }): Promise<ProcessingHistoryStats>

const stats = await client.processingHistory.stats({
  projectId: 'proj_abc123',
});
 
console.log('Total:', stats.total);
console.log('Pending:', stats.pending);
console.log('Processing:', stats.processing);
console.log('Completed:', stats.completed);
console.log('Failed:', stats.failed);

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

async upload(
  files: (File | Blob)[],
  params: BatchUploadParams,
): Promise<Batch>

import { readFileSync } from 'node:fs';
 
const files = ['invoice-01.pdf', 'invoice-02.pdf', 'invoice-03.pdf'].map(
  (name) => {
    const buffer = readFileSync(`./${name}`);
    return new File([buffer], name, { type: 'application/pdf' });
  },
);
 
const batch = await client.batch.upload(files, {
  projectId: 'proj_abc123',
  templateId: 'tmpl_xyz789',
  name: 'March Invoices',
  metadata: { month: 'march', year: '2026' },
});
 
console.log('Batch ID:', batch.id);
console.log('Total files:', batch.totalFiles);
console.log('Status:', batch.status);

async list(params?: ListBatchParams): Promise<PaginatedResponse<Batch>>

const result = await client.batch.list({
  projectId: 'proj_abc123',
  status: 'completed',
  page: 1,
  limit: 10,
});
 
console.log(`Total batches: ${result.pagination.total}`);
for (const batch of result.data) {
  console.log(`${batch.id}: ${batch.name} — ${batch.progress}% complete`);
}

async get(batchId: string): Promise<Batch>

const batch = await client.batch.get('batch_abc123');
 
console.log('Status:', batch.status);
console.log('Progress:', batch.progress, '%');
console.log(`${batch.completedFiles} / ${batch.totalFiles} files done`);
console.log('Failed:', batch.failedFiles);

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

async exportResults(batchId: string, params: ExportBatchParams): Promise<Blob>

// Export as JSON and parse
const blob = await client.batch.exportResults('batch_abc123', {
  format: 'json',
});
const results = JSON.parse(await blob.text());
console.log(`Exported ${results.length} results`);
 
// Export as CSV and save (Node.js)
import { writeFileSync } from 'node:fs';
 
const csvBlob = await client.batch.exportResults('batch_abc123', {
  format: 'csv',
});
writeFileSync('./batch-results.csv', Buffer.from(await csvBlob.arrayBuffer()));