TypeScript client

import { MeshQuClient } from '@meshqu/client';

const client = new MeshQuClient({
  baseUrl: 'https://api.meshqu.com',
  tenantId: 'your-tenant-id',
  apiKey: 'your-api-key',
  timeout: 5000,   // optional, milliseconds (default varies)
  retries: 3,      // optional, automatic retries on transient errors
});

const result = await client.evaluate({
  decision_type: 'trade_execution',
  fields: {
    account_id: 'ACC-001',
    instrument: 'AAPL',
    quantity: 100,
  },
  metadata: { source: 'order-service' },
});

// result.result.decision: 'ALLOW' | 'REVIEW' | 'DENY' | 'ALERT'
// result.result.violations: Violation[]
// result.result.rules_na: number (rules skipped due to when clause)
// result.result.na_rules: NaRule[] (details of skipped rules)
// result.result.signature: string | null (Ed25519, if signing enabled)
// result.result.signature_kid: string | null (e.g. 'msk_v1')

const decision = await client.record(
  {
    decision_type: 'trade_execution',
    fields: {
      account_id: 'ACC-001',
      instrument: 'AAPL',
      quantity: 100,
    },
    metadata: { source: 'order-service' },
  },
  {
    idempotency_key: 'order-12345',
  },
);

// decision.decision.id: string (UUID)
// decision.is_new: boolean
// decision.decision.decision: 'ALLOW' | 'REVIEW' | 'DENY' | 'ALERT'

import { randomUUID } from 'crypto';

const chainId = randomUUID();

// Step 1: Automated screening
const step1 = await client.record(
  {
    decision_type: 'aml_screening',
    fields: { transaction_amount: 150000, country: 'IR' },
  },
  {
    idempotency_key: 'case-42-screening',
    chain: { chain_id: chainId },
  },
);
// step1.decision.chain_step === 1 (auto-assigned)

// Step 2: Analyst review (references step 1 as parent)
const step2 = await client.record(
  {
    decision_type: 'aml_review',
    fields: { analyst_finding: 'legitimate_trade' },
  },
  {
    idempotency_key: 'case-42-review',
    chain: {
      chain_id: chainId,
      parent_decision_id: step1.decision.id,
    },
  },
);
// step2.decision.chain_step === 2 (auto-assigned)

// Human actor — compliance officer approving a case
const decision = await client.record(
  {
    decision_type: 'aml_analyst_review',
    fields: { analyst_finding: 'legitimate_trade' },
    metadata: { case_id: 'case-42' },
  },
  {
    idempotency_key: 'case-42-review',
    chain: {
      chain_id: chainId,
      parent_decision_id: step1.decision.id,
    },
  },
  {
    actor: {
      id: 'user-uuid-analyst',
      type: 'human',
      role: 'analyst',
      display_name: 'Alex Johnson',
    },
  },
);

// System actor — automated screening service
const screening = await client.record(
  {
    decision_type: 'aml_screening',
    fields: { transaction_amount: 150000, country: 'IR' },
  },
  { idempotency_key: 'case-42-screening', chain: { chain_id: chainId } },
  {
    actor: {
      id: 'screening-service',
      type: 'system',
      role: 'screening_service',
    },
  },
);

const list = await client.listDecisions({
  decision_type: 'trade_execution',
  decision: 'DENY',
  limit: 20,
});

// List by chain (returns steps in chain_step order)
const chainSteps = await client.listDecisions({
  chain_id: chainId,
});

const single = await client.getDecision('decision-uuid');

const replay = await client.replay('decision-uuid');
// Compare replay.replay.decision with replay.original.decision

const outcome = await client.recordOutcome('decision-uuid', {
  status: 'accepted',
  source_type: 'human',
  reported_by: 'ops-team',
});
// outcome.status: 'accepted' | 'overridden' | 'escalated' | 'expired' | 'abandoned'

// List
const policies = await client.listPolicies({ limit: 50 });

// Create (with conditional when clause)
const policy = await client.createPolicy({
  code: 'max-order-size',
  name: 'Max Order Size',
  description: 'Rejects orders above threshold.',
  decision_type: 'trade_execution',
  shadow_mode: false,
  rules: [
    {
      rule_code: 'SIZE-001',
      type: 'threshold',
      field: 'quantity',
      operator: '<=',
      value: 10000,
      severity: 'high',
      when: { field: 'instrument_type', equals: 'equity' }, // only applies to equities
    },
  ],
});

// Get
const fetched = await client.getPolicy(policy.id);

// Update metadata
await client.updatePolicy(policy.id, { shadow_mode: true });

// Deactivate
await client.deletePolicy(policy.id);

// Validate rules (dry-run)
await client.validatePolicy({ rules: [], decision_type: 'trade_execution' });

// Versions (new versions are created as draft)
await client.createPolicyVersion(policy.id, newRules, 'Increased threshold');
const versions = await client.listPolicyVersions(policy.id);
const v2 = await client.getPolicyVersion(policy.id, 2);

// Ratify a draft version (promotes to active)
const ratified = await client.ratifyVersion(policy.id, 2);
// ratified.status: 'ratified'
// ratified.ratified_by: string
// ratified.ratified_at: string (ISO 8601)

// List
const alerts = await client.listAlerts({ severity: 'critical' });

// Get
const alert = await client.getAlert('alert-uuid');

// Acknowledge
await client.acknowledgeAlert('alert-uuid', 'ops-team', 'Reviewed.');

// Create
const sub = await client.createSubscription(
  'https://your-service.com/webhooks/meshqu',
  { decision_types: ['trade_execution'], severity_min: 'high' },
);

// List
const subs = await client.listSubscriptions();

// Delete
await client.deleteSubscription(sub.id);

import {
  MeshQuError,
  MeshQuValidationError,
  MeshQuAuthError,
  MeshQuRateLimitError,
  MeshQuNetworkError,
  MeshQuTimeoutError,
} from '@meshqu/client';

try {
  await client.evaluate(context);
} catch (err) {
  if (err instanceof MeshQuRateLimitError) {
    // Wait and retry
  } else if (err instanceof MeshQuTimeoutError) {
    // Retry or circuit-break
  } else if (err instanceof MeshQuNetworkError) {
    // Connection failure
  }
}

import type {
  DecisionContext,
  Decision,
  ReasonCode,
  EvaluationResult,
  NaRule,
  Violation,
  Policy,
  PolicyVersion,
  Alert,
  AlertSubscription,
  Evidence,
  DecisionMetadata,
  SourceArtifact,
  When,
} from '@meshqu/client';