ImportExportApi

new ImportExportApi(baseUrl: string, options?: ImportExportApiOptions)

interface ImportExportApiOptions {
  /** Path base degli endpoint di import (default: '/import'). */
  importPath?: string
  /** Path base degli endpoint di export (default: '/export'). */
  exportPath?: string
}

// Default
new ImportExportApi('https://api.example.com')
// → importUrl = 'https://api.example.com/import'
// → exportUrl = 'https://api.example.com/export'

// Custom path
new ImportExportApi('https://api.example.com', {
  importPath: '/v2/import',
  exportPath: '/v2/export',
})
// → importUrl = 'https://api.example.com/v2/import'
// → exportUrl = 'https://api.example.com/v2/export'

uploadFile(
  file: File,
  risorsa: string,
  opzioniCsv?: Partial<CsvOpzioni>,
  valoriFissi?: Record<string, unknown>
): Promise<UploadResult>

testImport(sessionId: string, mappings: MappingColonna[]): Promise<TestImportResult>

executeImport(sessionId: string, mappings: MappingColonna[]): Promise<ImportResult>

getImportStatus(importId: string): Promise<ImportProgresso>

uploadImages(
  sessionId: string,
  files: File[]
): Promise<{ caricati: number; errori: string[] }>

downloadTemplate(risorsa: string, formato: string): Promise<Blob>

getImportHistory(risorsa?: string): Promise<ImportHistoryItem[]>

cancelUpload(): void

executeExport(
  request: ExportRequest
): Promise<ServerAsyncExportPayload | Blob>

// ordinamento: [{ campo: 'datagiro', direzione: 'desc' }, { campo: 'orapartenza', direzione: 'desc', nulls: 'last' }]
"opzioni": {
  "ordinamento": [
    { "campo": "datagiro", "direzione": "DESC" },
    { "campo": "orapartenza", "direzione": "DESC", "nulls": "LAST" }
  ]
}

getExportStatus(exportId: string): Promise<ExportProgresso>

downloadExport(url: string): Promise<Blob>

cancelExport(): void

getTemplates(risorsa?: string): Promise<ModelloExport[]>

createTemplate(
  template: Omit<ModelloExport, 'id' | 'dataCreazione' | 'dataModifica' | 'creatoDa'>
): Promise<ModelloExport>

updateTemplate(
  id: string,
  updates: Partial<ModelloExport>
): Promise<ModelloExport>

deleteTemplate(id: string): Promise<void>

getImportFieldMetadata(risorsa: string): Promise<CampoMetadato[]>

getExportFieldMetadata(risorsa: string): Promise<CampoMetadato[]>

import { ImportExportApi } from '@pzeta/vue-importexport'

const api = new ImportExportApi('https://api.example.com')

// Upload + test + execute
const upload = await api.uploadFile(file, 'anagrafica', { separatore: ';' })
const test = await api.testImport(upload.sessionId, mappings)

if (test.righeErrore === 0) {
  const result = await api.executeImport(upload.sessionId, mappings)
  console.log(`Importate: ${result.righeImportate}`)
}

// downloadBlob della libreria è interno: qui un helper dell'app
function downloadBlob(blob: Blob, nomeFile: string) {
  const url = URL.createObjectURL(blob)
  const a = Object.assign(document.createElement('a'), { href: url, download: nomeFile })
  a.click()
  URL.revokeObjectURL(url)
}

const result = await api.executeExport({
  risorsa: 'anagrafica',
  formato: 'xlsx',
  campi: ['nome', 'cognome', 'email'],
  nomeFile: 'Anagrafiche 2026-10-15',
  filtri: { attivo: true, datanascita: { operator: 'between', value: ['1980-01-01', '1989-12-31'] } },
  ordinamento: [
    { campo: 'cognome', direzione: 'asc' },
    { campo: 'email', direzione: 'asc', nulls: 'last' },
  ],
})

if (result instanceof Blob) {
  // Sincrono: salva direttamente
  downloadBlob(result, 'anagrafica.xlsx')
} else {
  // Asincrono: poll fino a completamento
  let status = result
  while (status.stato === 'in_corso') {
    await new Promise((r) => setTimeout(r, 2000))
    status = await api.getExportStatus(result.exportId)
  }
  if (status.urlDownload) {
    const blob = await api.downloadExport(status.urlDownload)
    downloadBlob(blob, status.nomeFile ?? 'export.xlsx')
  }
}

class ApiError extends Error {
  readonly name: 'ApiError'
  /** Stato HTTP; 0 se la richiesta non è arrivata al servizio */
  readonly status: number
  /** `message` del corpo della risposta, se è una stringa non vuota */
  readonly messaggioServizio: string | null
}

import { ApiError } from '@pzeta/vue-importexport'

try {
  await api.createTemplate(modello)
} catch (e) {
  if (e instanceof ApiError && e.status === 403) {
    console.warn(e.messaggioServizio)   // «Solo un amministratore può condividere…»
  }
}