> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fhiron.cl/llms.txt
> Use this file to discover all available pages before exploring further.

# validate

> Valida un recurso FHIR® (o Bundle) contra CL Core v1.9.4 en el motor remoto. Descuenta cuota del plan.

`validate()` envía el recurso al motor de Fhiron (HAPI más perfiles CL Core) y devuelve los hallazgos en español. **Descuenta 1 de la cuota mensual del tenant** por recurso validado.

```ts theme={null}
import { Fhiron } from '@fhiron/sdk';

const fhiron = new Fhiron({ apiKey: process.env.FHIRON_API_KEY });

const result = await fhiron.validate(medicationRequest);

if (result.ok) {
  // sigue tu flujo: persistir, reenviar al EHR, etc.
} else {
  result.errors.forEach((e) => console.log(e.code, e.path, e.message));
}
```

## Firma

```ts theme={null}
validate(resource: object, opts?: {
  profile?: string;        // "hl7.fhir.cl.clcore@1.9.4" o "1.9.4"
  clCoreVersion?: string;  // override puntual de la versión
  timeout?: number;        // ms
}): Promise<ValidateResult>
```

El `resource` debe tener `resourceType` en la raíz. Funciona también con Bundles (`resourceType: "Bundle"`).

## El resultado

```ts theme={null}
interface ValidateResult {
  valid: boolean;            // el motor no encontró errores
  ok: boolean;               // valid && !engineDegraded: úsalo como gate
  engineDegraded: boolean;   // el motor no pudo validar (no se descontó cuota)
  resourceType: string | null;
  profile: string | null;
  issues: Issue[];           // todos los hallazgos
  errors: Issue[];           // atajo: severity === 'error'
  warnings: Issue[];
  information: Issue[];
  messages: { errors: string[]; warnings: string[] };
  raw: Record<string, unknown>;  // respuesta cruda del endpoint
}
```

Cada `Issue` trae `code`, `severity`, `path`, `message` y, cuando aplica, `profileUrl`, `suggestion`, `why` y `quickFix`. Ver [referencia](/sdk/referencia).

## Usar `ok` como gate

```ts theme={null}
const result = await fhiron.validate(resource);
if (!result.ok) {
  throw new Error(`Recurso no cumple CL Core: ${result.errors.map((e) => e.message).join('; ')}`);
}
await ehr.post(resource);
```

`ok` es `valid && !engineDegraded`: solo es `true` cuando el motor realmente validó y no encontró errores. Cuando `engineDegraded` es `true`, el motor remoto tuvo un problema sistémico, **no se descontó cuota** y conviene reintentar.

## Elegir la versión de CL Core

Por defecto la versión la resuelve tu tenant. Para fijar una puntual:

```ts theme={null}
await fhiron.validate(resource, { profile: 'hl7.fhir.cl.clcore@1.9.4' });
// o
await fhiron.validate(resource, { clCoreVersion: '1.9.4' });
```

## Lint local + validación remota

`check()` corre el [lint offline](/sdk/lint) y la validación remota en un solo llamado, y adjunta `localIssues`:

```ts theme={null}
const result = await fhiron.check(resource);
console.log(result.localIssues); // hallazgos estructurales inmediatos
console.log(result.errors);      // hallazgos del motor remoto
```

## Manejo de errores

`validate()` lanza errores tipados ante fallos HTTP o de red. Ver [errores](/sdk/errores).

```ts theme={null}
import { FhironQuotaError } from '@fhiron/sdk';

try {
  await fhiron.validate(resource);
} catch (err) {
  if (err instanceof FhironQuotaError) {
    console.log('Cuota agotada. Upgrade en', err.upgradeUrl);
  }
}
```