import { HybriDBClient } from '@hybridb/sdk';

const hdb = new HybriDBClient({
  baseUrl: 'https://hybridb.stellrai.com',
  apiKey:  process.env.HYBRIDB_API_KEY!,
});

const execution = await hdb.triggerPipeline({
  pipelineId:     'process-payment',
  input:          { userId: 'u_123', amount: 15000, currency: 'USD' },
  idempotencyKey: crypto.randomUUID(),
});

console.log(execution.id);     // exec_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
console.log(execution.status); // 'completed'

if (execution.status === 'failed') {
  const result = await hdb.reversibility.rollback(execution.id, {
    rollbackType: 'full',
    reason:       'Payment processor returned 422',
  });

  console.log(result.outcome);         // 'success'
  console.log(result.stepsRolledBack); // ['charge', 'reserve', 'notify']
  console.log(result.durationMs);      // 2840
}

const checkpoints = await hdb.reversibility.getCheckpoints(execution.id);

const replay = await hdb.reversibility.replay(execution.id, {
  fromCheckpoint: checkpoints[1].id,  // resume after step 2 — not from step zero
  reason:         'Retry notification step after rate limit',
});

console.log(replay.newExecutionId);    // new child execution
console.log(replay.parentExecutionId); // original execution

const hdb = new HybriDBClient({
  baseUrl:     string,   // required — e.g. 'https://hybridb.stellrai.com'
  apiKey:      string,   // required — your Stellrai API key
  timeout?:    number,   // ms, default 10000
  retries?:    number,   // default 3
  retryDelay?: number,   // ms, default 500
});

hdb.triggerPipeline(input)           // trigger a governed pipeline
hdb.getPipelineExecution(executionId) // get execution status

hdb.reversibility.rollback(executionId, input)          // rollback full / selective / to checkpoint
hdb.reversibility.replay(executionId, input)            // replay from a specific checkpoint
hdb.reversibility.getCheckpoints(executionId)           // list all checkpoints
hdb.reversibility.getCheckpoint(executionId, id)        // get checkpoint (checksum-verified)
hdb.reversibility.getRollbackLog(executionId)           // audit log of rollback operations
hdb.reversibility.getCircuitBreaker(pipelineId)         // get circuit breaker status
hdb.reversibility.setCircuitBreaker(pipelineId, input)  // open / close circuit breaker

hdb.requestDecision(request) // policy-governed decision
hdb.getDecision(decisionId)  // retrieve a past decision

hdb.authenticate(input)         // email + password → token pair
hdb.refreshToken(refreshToken)  // refresh an access token
hdb.revokeSession()             // invalidate current session
hdb.verifyToken(token)          // local JWT verification via JWKS (requires jose)
hdb.actors.createApiKey(actorId, input)
hdb.actors.revokeApiKey(actorId, keyId)
hdb.actors.createMapping(actorId, input)
hdb.orgs.addMember(orgId, input)
hdb.orgs.updateMemberRole(orgId, actorId, role)
hdb.orgs.revokeMember(orgId, actorId)
hdb.orgs.listMembers(orgId)

hdb.publishEvent(input)          // publish a business event
hdb.queryAuditLog(params)        // query the immutable audit log
hdb.health()                     // check API status

import { HybriDBProvider, useHybriDBClient } from '@hybridb/sdk/react';

// Wrap at app root
<HybriDBProvider client={hdb}>
  {children}
</HybriDBProvider>

// Use in any component
const { client } = useHybriDBClient();

import { HybriDBClient, HybriDBError } from '@hybridb/sdk';

try {
  const execution = await hdb.triggerPipeline({ ... });
} catch (err) {
  if (err instanceof HybriDBError) {
    console.error(err.code);    // e.g. 'POLICY_BLOCKED', 'RATE_LIMITED'
    console.error(err.message); // human-readable description
    console.error(err.details); // structured detail object (when present)
  }
  throw err; // let errors propagate — don't hide governance failures
}