TypeScript SDK

import { MeshQuClient } from '@tradequ/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'

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

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

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

// 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',
  advisory_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, { advisory_mode: true });

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

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

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

// 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 '@tradequ/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,
  EvaluationResult,
  NaRule,
  Violation,
  Policy,
  PolicyVersion,
  Alert,
  AlertSubscription,
  Evidence,
  DecisionMetadata,
  SourceArtifact,
  When,
} from '@tradequ/meshqu-client';