@robosystems/client 0.3.9 → 0.3.11

package/artifacts/LedgerClient.ts

@@ -29,86 +29,73 @@ import {
   opAutoMapElements,
   opBuildFactGrid,
   opClosePeriod,
-  opCreateAssociations,
-  opCreateClosingEntry,
-  opCreateElement,
+  opCreateAgent,
+  opCreateEventBlock,
+  opCreateEventHandler,
   opCreateInformationBlock,
-  opCreateJournalEntry,
-  opCreateManualClosingEntry,
   opCreateMappingAssociation,
   opCreatePublishList,
   opCreateReport,
-  opCreateStructure,
-  opCreateTaxonomy,
-  opCreateTransaction,
-  opDeleteAssociation,
-  opDeleteElement,
+  opCreateTaxonomyBlock,
   opDeleteInformationBlock,
   opDeleteJournalEntry,
   opDeleteMappingAssociation,
   opDeletePublishList,
   opDeleteReport,
-  opDeleteStructure,
-  opDeleteTaxonomy,
+  opDeleteTaxonomyBlock,
+  opEvaluateRules,
+  opFinancialStatementAnalysis,
   opInitializeLedger,
   opLinkEntityTaxonomy,
+  opLiveFinancialStatement,
+  opPreviewEventBlock,
   opRegenerateReport,
   opRemovePublishListMember,
   opReopenPeriod,
-  opReverseJournalEntry,
   opSetCloseTarget,
   opShareReport,
-  opTruncateSchedule,
-  opUpdateAssociation,
-  opUpdateElement,
+  opUpdateAgent,
   opUpdateEntity,
+  opUpdateEventBlock,
+  opUpdateEventHandler,
   opUpdateInformationBlock,
   opUpdateJournalEntry,
   opUpdatePublishList,
-  opUpdateStructure,
-  opUpdateTaxonomy,
+  opUpdateTaxonomyBlock,
 } from '../sdk.gen'
 import type {
   AddPublishListMembersOperation,
   AutoMapElementsOperation,
-  BulkAssociationItem,
-  BulkCreateAssociationsRequest,
   ClosePeriodOperation,
-  CreateClosingEntryOperation,
-  CreateElementRequest,
+  CreateAgentRequest,
+  CreateEventBlockRequest,
+  CreateEventHandlerRequest,
   CreateInformationBlockRequest,
-  CreateJournalEntryRequest,
-  CreateManualClosingEntryRequest,
   CreateMappingAssociationOperation,
   CreatePublishListRequest,
   CreateReportRequest,
-  CreateStructureRequest,
-  CreateTaxonomyRequest,
-  CreateTransactionRequest,
+  CreateTaxonomyBlockRequest,
   CreateViewRequest,
-  DeleteAssociationRequest,
-  DeleteElementRequest,
   DeleteInformationBlockRequest,
   DeleteJournalEntryRequest,
   DeleteMappingAssociationOperation,
-  DeleteStructureRequest,
-  DeleteTaxonomyRequest,
+  DeleteTaxonomyBlockRequest,
+  EvaluateRulesRequest,
+  FinancialStatementAnalysisRequest,
   InitializeLedgerRequest,
-  JournalEntryLineItemInput,
   LinkEntityTaxonomyRequest,
+  LiveFinancialStatementRequest,
   OperationEnvelope,
   ReopenPeriodOperation,
-  ReverseJournalEntryRequest,
   SetCloseTargetOperation,
-  TruncateScheduleOperation,
-  UpdateAssociationRequest,
-  UpdateElementRequest,
+  UpdateAgentRequest,
   UpdateEntityRequest,
+  UpdateEventBlockRequest,
+  UpdateEventHandlerRequest,
   UpdateInformationBlockRequest,
   UpdateJournalEntryRequest,
   UpdatePublishListOperation,
-  UpdateStructureRequest,
-  UpdateTaxonomyRequest,
+  UpdateTaxonomyBlockRequest,
 } from '../types.gen'
 import type { TokenProvider } from './graphql/client'
 import { GraphQLClientCache } from './graphql/client'
@@ -315,18 +302,6 @@ interface RawClosePeriodResult {
   fiscal_calendar: RawFiscalCalendar
 }
 
-interface RawClosingEntryResult {
-  outcome: ClosingEntryOutcome
-  entry_id: string | null
-  status: string | null
-  posting_date: string | null
-  memo: string | null
-  debit_element_id: string | null
-  credit_element_id: string | null
-  amount: number | null
-  reason: string | null
-}
-
 interface RawScheduleCreatedResult {
   structure_id: string
   name: string
@@ -335,13 +310,6 @@ interface RawScheduleCreatedResult {
   total_facts: number
 }
 
-interface RawTruncateScheduleResult {
-  structure_id: string
-  new_end_date: string
-  facts_deleted: number
-  reason: string
-}
-
 export interface InitializeLedgerResult {
   fiscalCalendar: LedgerFiscalCalendar
   periodsCreated: number
@@ -355,20 +323,6 @@ export interface ClosePeriodResult {
   fiscalCalendar: LedgerFiscalCalendar
 }
 
-export type ClosingEntryOutcome = 'created' | 'unchanged' | 'regenerated' | 'removed' | 'skipped'
-
-export interface ClosingEntry {
-  outcome: ClosingEntryOutcome
-  entryId: string | null
-  status: string | null
-  postingDate: string | null
-  memo: string | null
-  debitElementId: string | null
-  creditElementId: string | null
-  amount: number | null
-  reason: string | null
-}
-
 export interface ScheduleCreated {
   structureId: string
   name: string
@@ -377,13 +331,6 @@ export interface ScheduleCreated {
   totalFacts: number
 }
 
-export interface TruncateScheduleResult {
-  structureId: string
-  newEndDate: string
-  factsDeleted: number
-  reason: string
-}
-
 export type LedgerEntryType = 'standard' | 'adjusting' | 'closing' | 'reversing'
 
 // ── Caller-facing option interfaces ────────────────────────────────────
@@ -401,25 +348,6 @@ export interface ClosePeriodOptions {
   allowStaleSync?: boolean
 }
 
-export interface ManualClosingLineItem {
-  elementId: string
-  debitAmount?: number
-  creditAmount?: number
-  description?: string | null
-}
-
-export interface CreateManualClosingEntryOptions {
-  postingDate: string
-  memo: string
-  lineItems: ManualClosingLineItem[]
-  entryType?: LedgerEntryType
-}
-
-export interface TruncateScheduleOptions {
-  newEndDate: string
-  reason: string
-}
-
 export interface CreateScheduleOptions {
   name: string
   elementIds: string[]
@@ -641,56 +569,6 @@ export class LedgerClient {
     )
   }
 
-  /**
-   * Create a standalone business-event Transaction without entries.
-   *
-   * Returns a `transaction_id` that can be passed to `createJournalEntry`
-   * to attach entries to this event. Use when a single event (invoice,
-   * payment, deposit) produces multiple entries over its lifecycle.
-   *
-   * `amount` is in minor currency units (cents).
-   * `type` is free-form: invoice, payment, bill, expense, deposit, etc.
-   */
-  async createTransaction(
-    graphId: string,
-    options: {
-      type: string
-      date: string
-      amount: number
-      currency?: string
-      description?: string
-      merchantName?: string
-      referenceNumber?: string
-      number?: string
-      category?: string
-      dueDate?: string
-      status?: 'pending' | 'posted'
-      idempotencyKey?: string
-    }
-  ): Promise<Record<string, unknown>> {
-    const body: CreateTransactionRequest = {
-      type: options.type,
-      date: options.date,
-      amount: options.amount,
-      currency: options.currency ?? 'USD',
-      status: options.status ?? 'pending',
-      description: options.description ?? null,
-      merchant_name: options.merchantName ?? null,
-      reference_number: options.referenceNumber ?? null,
-      number: options.number ?? null,
-      category: options.category ?? null,
-      due_date: options.dueDate ?? null,
-    }
-    const headers = options.idempotencyKey
-      ? { 'Idempotency-Key': options.idempotencyKey }
-      : undefined
-    const envelope = await this.callOperation(
-      'Create transaction',
-      opCreateTransaction({ path: { graph_id: graphId }, body, headers })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
   // ── Trial Balance ──────────────────────────────────────────────────
 
   /** Trial balance by raw CoA account. */
@@ -757,53 +635,60 @@ export class LedgerClient {
     return list?.taxonomies ?? []
   }
 
-  /** Create a new taxonomy (used for CoA + mapping taxonomies). */
-  async createTaxonomy(
+  /**
+   * Link the graph's entity to a taxonomy (ENTITY_HAS_TAXONOMY edge).
+   * Idempotent — returns existing linkage if already present.
+   */
+  async linkEntityTaxonomy(
     graphId: string,
-    body: CreateTaxonomyRequest
+    body: LinkEntityTaxonomyRequest
   ): Promise<Record<string, unknown>> {
     const envelope = await this.callOperation(
-      'Create taxonomy',
-      opCreateTaxonomy({ path: { graph_id: graphId }, body })
+      'Link entity taxonomy',
+      opLinkEntityTaxonomy({ path: { graph_id: graphId }, body })
     )
     return (envelope.result ?? {}) as Record<string, unknown>
   }
 
-  /** Update mutable fields on a taxonomy. `taxonomy_type` is immutable. */
-  async updateTaxonomy(
+  /**
+   * Create a taxonomy block atomically (taxonomy + structures + elements +
+   * associations + rules in one envelope).
+   */
+  async createTaxonomyBlock(
     graphId: string,
-    body: UpdateTaxonomyRequest
+    body: CreateTaxonomyBlockRequest,
+    idempotencyKey?: string
   ): Promise<Record<string, unknown>> {
+    const headers = idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined
     const envelope = await this.callOperation(
-      'Update taxonomy',
-      opUpdateTaxonomy({ path: { graph_id: graphId }, body })
+      'Create taxonomy block',
+      opCreateTaxonomyBlock({ path: { graph_id: graphId }, body, headers })
     )
     return (envelope.result ?? {}) as Record<string, unknown>
   }
 
-  /** Soft-delete a taxonomy (`is_active=false`). */
-  async deleteTaxonomy(graphId: string, taxonomyId: string): Promise<Record<string, unknown>> {
-    const body: DeleteTaxonomyRequest = { taxonomy_id: taxonomyId }
+  /** Update a taxonomy block — add/update/remove elements, structures, associations, or rules. */
+  async updateTaxonomyBlock(
+    graphId: string,
+    body: UpdateTaxonomyBlockRequest
+  ): Promise<Record<string, unknown>> {
     const envelope = await this.callOperation(
-      'Delete taxonomy',
-      opDeleteTaxonomy({ path: { graph_id: graphId }, body })
+      'Update taxonomy block',
+      opUpdateTaxonomyBlock({ path: { graph_id: graphId }, body })
     )
     return (envelope.result ?? {}) as Record<string, unknown>
   }
 
-  /**
-   * Link the graph's entity to a taxonomy (ENTITY_HAS_TAXONOMY edge).
-   * Idempotent — returns existing linkage if already present.
-   */
-  async linkEntityTaxonomy(
+  /** Delete a taxonomy block. Cascades through elements, structures, and associations. */
+  async deleteTaxonomyBlock(
     graphId: string,
-    body: LinkEntityTaxonomyRequest
-  ): Promise<Record<string, unknown>> {
+    body: DeleteTaxonomyBlockRequest
+  ): Promise<{ deleted: boolean }> {
     const envelope = await this.callOperation(
-      'Link entity taxonomy',
-      opLinkEntityTaxonomy({ path: { graph_id: graphId }, body })
+      'Delete taxonomy block',
+      opDeleteTaxonomyBlock({ path: { graph_id: graphId }, body })
     )
-    return (envelope.result ?? {}) as Record<string, unknown>
+    return (envelope.result ?? { deleted: true }) as { deleted: boolean }
   }
 
   /** List elements (CoA accounts, GAAP concepts, etc.) with filters. */
@@ -848,40 +733,6 @@ export class LedgerClient {
     )
   }
 
-  /** Create a new element within a taxonomy (native CoA account, etc.). */
-  async createElement(
-    graphId: string,
-    body: CreateElementRequest
-  ): Promise<Record<string, unknown>> {
-    const envelope = await this.callOperation(
-      'Create element',
-      opCreateElement({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
-  /** Update mutable fields on an element. `taxonomy_id` and `source` are immutable. */
-  async updateElement(
-    graphId: string,
-    body: UpdateElementRequest
-  ): Promise<Record<string, unknown>> {
-    const envelope = await this.callOperation(
-      'Update element',
-      opUpdateElement({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
-  /** Soft-delete an element (`is_active=false`). */
-  async deleteElement(graphId: string, elementId: string): Promise<Record<string, unknown>> {
-    const body: DeleteElementRequest = { element_id: elementId }
-    const envelope = await this.callOperation(
-      'Delete element',
-      opDeleteElement({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
   // ── Structures ──────────────────────────────────────────────────────
 
   /** List reporting structures (IS, BS, CF, schedules) with optional filters. */
@@ -902,62 +753,6 @@ export class LedgerClient {
     return list?.structures ?? []
   }
 
-  /**
-   * Create a new structure. Most common use is a CoA→reporting mapping
-   * structure; also used for custom statement + schedule structures.
-   */
-  async createStructure(graphId: string, body: CreateStructureRequest): Promise<LedgerMappingInfo> {
-    const envelope = await this.callOperation(
-      'Create structure',
-      opCreateStructure({ path: { graph_id: graphId }, body })
-    )
-    return envelope.result as unknown as LedgerMappingInfo
-  }
-
-  /** Convenience wrapper — create a CoA→GAAP mapping structure. */
-  async createMappingStructure(
-    graphId: string,
-    options?: {
-      name?: string
-      description?: string | null
-      taxonomyId?: string
-    }
-  ): Promise<LedgerMappingInfo> {
-    const body: CreateStructureRequest = {
-      name: options?.name ?? 'CoA to Reporting',
-      structure_type: 'coa_mapping',
-      taxonomy_id: options?.taxonomyId ?? 'tax_usgaap_reporting',
-      description: options?.description ?? 'Map Chart of Accounts to US GAAP reporting concepts',
-    }
-    const envelope = await this.callOperation(
-      'Create mapping structure',
-      opCreateStructure({ path: { graph_id: graphId }, body })
-    )
-    return envelope.result as unknown as LedgerMappingInfo
-  }
-
-  /** Update mutable fields on a structure. `structure_type` is immutable. */
-  async updateStructure(
-    graphId: string,
-    body: UpdateStructureRequest
-  ): Promise<Record<string, unknown>> {
-    const envelope = await this.callOperation(
-      'Update structure',
-      opUpdateStructure({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
-  /** Soft-delete a structure (`is_active=false`). */
-  async deleteStructure(graphId: string, structureId: string): Promise<Record<string, unknown>> {
-    const body: DeleteStructureRequest = { structure_id: structureId }
-    const envelope = await this.callOperation(
-      'Delete structure',
-      opDeleteStructure({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
   // ── Mappings ────────────────────────────────────────────────────────
 
   /** List active CoA→reporting mapping structures. */
@@ -1037,42 +832,6 @@ export class LedgerClient {
     return { operationId: envelope.operationId, status: envelope.status }
   }
 
-  /** Bulk create associations within a single structure, atomically. */
-  async createAssociations(
-    graphId: string,
-    structureId: string,
-    associations: BulkAssociationItem[]
-  ): Promise<Record<string, unknown>> {
-    const body: BulkCreateAssociationsRequest = { structure_id: structureId, associations }
-    const envelope = await this.callOperation(
-      'Create associations',
-      opCreateAssociations({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
-  /** Update mutable fields on an association (order, weight, confidence). */
-  async updateAssociation(
-    graphId: string,
-    body: UpdateAssociationRequest
-  ): Promise<Record<string, unknown>> {
-    const envelope = await this.callOperation(
-      'Update association',
-      opUpdateAssociation({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? {}) as Record<string, unknown>
-  }
-
-  /** Hard-delete an association (any type: presentation, calculation, mapping). */
-  async deleteAssociation(graphId: string, associationId: string): Promise<{ deleted: boolean }> {
-    const body: DeleteAssociationRequest = { association_id: associationId }
-    const envelope = await this.callOperation(
-      'Delete association',
-      opDeleteAssociation({ path: { graph_id: graphId }, body })
-    )
-    return (envelope.result ?? { deleted: true }) as { deleted: boolean }
-  }
-
   // ── Information Blocks ─────────────────────────────────────────────
 
   /**
@@ -1194,28 +953,57 @@ export class LedgerClient {
     return (envelope.result ?? { deleted: true }) as { deleted: boolean }
   }
 
-  /** Truncate a schedule — end it early at `newEndDate`. */
-  async truncateSchedule(
+  /**
+   * Dispose of a schedule asset — atomically truncates forward facts,
+   * deletes the SumEquals rule, and posts a balanced disposal entry.
+   *
+   * Routes through `create-event-block` with `event_type='asset_disposed'`.
+   * `occurred_at` is required and represents the disposal date.
+   */
+  async disposeSchedule(
     graphId: string,
-    structureId: string,
-    options: TruncateScheduleOptions
-  ): Promise<TruncateScheduleResult> {
-    const body: TruncateScheduleOperation = {
-      structure_id: structureId,
-      new_end_date: options.newEndDate,
-      reason: options.reason,
+    options: {
+      scheduleId: string
+      occurredAt: string
+      proceeds?: number
+      proceedsElementId?: string | null
+      gainLossElementId?: string | null
+      memo?: string | null
+      reason?: string
+    }
+  ): Promise<Record<string, unknown>> {
+    const body: CreateEventBlockRequest = {
+      event_type: 'asset_disposed',
+      event_category: 'adjustment',
+      source: 'native',
+      occurred_at: options.occurredAt,
+      apply_handlers: true,
+      metadata: {
+        schedule_id: options.scheduleId,
+        proceeds: options.proceeds ?? 0,
+        proceeds_element_id: options.proceedsElementId ?? null,
+        gain_loss_element_id: options.gainLossElementId ?? null,
+        memo: options.memo ?? null,
+        reason: options.reason ?? 'asset_disposed_event',
+      },
     }
     const envelope = await this.callOperation(
-      'Truncate schedule',
-      opTruncateSchedule({ path: { graph_id: graphId }, body })
+      'Dispose schedule',
+      opCreateEventBlock({ path: { graph_id: graphId }, body })
     )
-    const raw = envelope.result as unknown as RawTruncateScheduleResult
-    return {
-      structureId: raw.structure_id,
-      newEndDate: raw.new_end_date,
-      factsDeleted: raw.facts_deleted,
-      reason: raw.reason,
-    }
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  /** Evaluate taxonomy rules against facts in a structure. */
+  async evaluateRules(
+    graphId: string,
+    body: EvaluateRulesRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Evaluate rules',
+      opEvaluateRules({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
   }
 
   // ── Period close ────────────────────────────────────────────────────
@@ -1248,7 +1036,12 @@ export class LedgerClient {
 
   /**
    * Idempotently create (or refresh) a draft closing entry from a
-   * schedule for a period. See `ClosingEntryOutcome` for semantics.
+   * schedule for a period.
+   *
+   * Routes through `create-event-block` with
+   * `event_type='schedule_entry_due'`. Returns the EventBlockEnvelope —
+   * the underlying handler is idempotent and dispatches to one of
+   * created / unchanged / regenerated / removed / skipped internally.
    */
   async createClosingEntry(
     graphId: string,
@@ -1257,45 +1050,26 @@ export class LedgerClient {
     periodStart: string,
     periodEnd: string,
     memo?: string
-  ): Promise<ClosingEntry> {
-    const body: CreateClosingEntryOperation = {
-      structure_id: structureId,
-      posting_date: postingDate,
-      period_start: periodStart,
-      period_end: periodEnd,
-      memo: memo ?? undefined,
+  ): Promise<Record<string, unknown>> {
+    const body: CreateEventBlockRequest = {
+      event_type: 'schedule_entry_due',
+      event_category: 'recognition',
+      source: 'scheduled',
+      occurred_at: `${postingDate}T00:00:00Z`,
+      apply_handlers: true,
+      metadata: {
+        schedule_id: structureId,
+        posting_date: postingDate,
+        period_start: periodStart,
+        period_end: periodEnd,
+        memo: memo ?? null,
+      },
     }
     const envelope = await this.callOperation(
       'Create closing entry',
-      opCreateClosingEntry({ path: { graph_id: graphId }, body })
-    )
-    return rawToClosingEntry(envelope.result as unknown as RawClosingEntryResult)
-  }
-
-  /**
-   * Create a manual balanced closing entry (not tied to a schedule).
-   * Used for disposals, adjustments, and one-off closing events.
-   */
-  async createManualClosingEntry(
-    graphId: string,
-    options: CreateManualClosingEntryOptions
-  ): Promise<ClosingEntry> {
-    const body: CreateManualClosingEntryRequest = {
-      posting_date: options.postingDate,
-      memo: options.memo,
-      entry_type: options.entryType,
-      line_items: options.lineItems.map((li) => ({
-        element_id: li.elementId,
-        debit_amount: li.debitAmount ?? 0,
-        credit_amount: li.creditAmount ?? 0,
-        description: li.description ?? null,
-      })),
-    }
-    const envelope = await this.callOperation(
-      'Create manual closing entry',
-      opCreateManualClosingEntry({ path: { graph_id: graphId }, body })
+      opCreateEventBlock({ path: { graph_id: graphId }, body })
     )
-    return rawToClosingEntry(envelope.result as unknown as RawClosingEntryResult)
+    return (envelope.result ?? {}) as Record<string, unknown>
   }
 
   // ── Closing book ───────────────────────────────────────────────────
@@ -1410,35 +1184,48 @@ export class LedgerClient {
   /**
    * Create a journal entry with balanced line items (DR=CR enforced).
    *
-   * Defaults to `status='draft'`. Pass `status='posted'` for historical
-   * data import where entries represent already-happened business events.
+   * Routes through `create-event-block` with
+   * `event_type='journal_entry_recorded'` — the Python handler forwards
+   * to the internal journal-entry command. Defaults to `status='draft'`;
+   * pass `status='posted'` for historical data imports.
    *
    * Supply `idempotencyKey` to make the call safe to retry — replays
    * within 24 hours return the same envelope. Reusing the key with a
    * different body returns HTTP 409.
+   *
+   * Returns the EventBlockEnvelope (event row fields); query the ledger
+   * separately if you need the resulting entry_id.
    */
   async createJournalEntry(
     graphId: string,
     options: CreateJournalEntryOptions
   ): Promise<Record<string, unknown>> {
-    const body: CreateJournalEntryRequest = {
-      posting_date: options.postingDate,
-      memo: options.memo,
-      line_items: options.lineItems.map(
-        (li): JournalEntryLineItemInput => ({
+    const body: CreateEventBlockRequest = {
+      event_type: 'journal_entry_recorded',
+      event_category: 'adjustment',
+      source: 'native',
+      occurred_at: `${options.postingDate}T00:00:00Z`,
+      apply_handlers: true,
+      metadata: {
+        posting_date: options.postingDate,
+        memo: options.memo,
+        line_items: options.lineItems.map((li) => ({
           element_id: li.elementId,
           debit_amount: li.debitAmount,
           credit_amount: li.creditAmount,
           description: li.description ?? null,
-        })
-      ),
-      type: options.type,
-      status: options.status,
-      transaction_id: options.transactionId ?? null,
+        })),
+        type: options.type ?? 'standard',
+        status: options.status ?? 'draft',
+        transaction_id: options.transactionId ?? null,
+      },
     }
+    const headers = options.idempotencyKey
+      ? { 'Idempotency-Key': options.idempotencyKey }
+      : undefined
     const envelope = await this.callOperation(
       'Create journal entry',
-      opCreateJournalEntry({ path: { graph_id: graphId }, body })
+      opCreateEventBlock({ path: { graph_id: graphId }, body, headers })
     )
     return (envelope.result ?? {}) as Record<string, unknown>
   }
@@ -1468,20 +1255,177 @@ export class LedgerClient {
   /**
    * Reverse a posted journal entry — creates an offsetting entry and marks
    * the original as reversed.
+   *
+   * Routes through `create-event-block` with
+   * `event_type='journal_entry_reversed'`.
    */
   async reverseJournalEntry(
     graphId: string,
     entryId: string,
-    options?: { postingDate?: string | null; memo?: string | null }
+    options?: {
+      postingDate?: string | null
+      memo?: string | null
+      reason?: string | null
+    }
   ): Promise<Record<string, unknown>> {
-    const body: ReverseJournalEntryRequest = {
-      entry_id: entryId,
-      posting_date: options?.postingDate ?? null,
-      memo: options?.memo ?? null,
+    const occurredDate = options?.postingDate ?? new Date().toISOString().slice(0, 10)
+    const body: CreateEventBlockRequest = {
+      event_type: 'journal_entry_reversed',
+      event_category: 'adjustment',
+      source: 'native',
+      occurred_at: `${occurredDate}T00:00:00Z`,
+      apply_handlers: true,
+      metadata: {
+        entry_id: entryId,
+        posting_date: options?.postingDate ?? null,
+        memo: options?.memo ?? null,
+        reason: options?.reason ?? null,
+      },
     }
     const envelope = await this.callOperation(
       'Reverse journal entry',
-      opReverseJournalEntry({ path: { graph_id: graphId }, body })
+      opCreateEventBlock({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  // ── Event blocks (generic preview + status transitions) ──────────────
+
+  /**
+   * Dry-run an event block — resolve the handler, evaluate metadata, and
+   * return the planned GL rows without writing anything. Companion to
+   * `createJournalEntry` / `reverseJournalEntry` / `createClosingEntry` /
+   * `disposeSchedule`: pass the same body you'd send to those methods
+   * (the underlying `CreateEventBlockRequest`) and inspect what the
+   * handler would do.
+   */
+  async previewEventBlock(
+    graphId: string,
+    body: CreateEventBlockRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Preview event block',
+      opPreviewEventBlock({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  /**
+   * Apply a status transition and/or field corrections to an existing
+   * event block. Use for posting drafts (`classified` → `committed` →
+   * `fulfilled`), voiding, superseding (correction chains), or patching
+   * `description` / `effective_at` / `metadata`.
+   */
+  async updateEventBlock(
+    graphId: string,
+    body: UpdateEventBlockRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Update event block',
+      opUpdateEventBlock({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  // ── Agents (REA counterparties) ───────────────────────────────────────
+
+  /**
+   * Create an agent — REA counterparty (customer, vendor, employee, etc.)
+   * referenced by event blocks via `agent_id`. `(source, external_id)` is
+   * unique when `external_id` is provided, so external-source ingestion is
+   * idempotent at the DB level.
+   */
+  async createAgent(
+    graphId: string,
+    body: CreateAgentRequest,
+    idempotencyKey?: string
+  ): Promise<Record<string, unknown>> {
+    const headers = idempotencyKey ? { 'Idempotency-Key': idempotencyKey } : undefined
+    const envelope = await this.callOperation(
+      'Create agent',
+      opCreateAgent({ path: { graph_id: graphId }, body, headers })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  /**
+   * Update an agent. `metadata_patch` is a partial merge into the existing
+   * metadata object; all other fields replace.
+   */
+  async updateAgent(graphId: string, body: UpdateAgentRequest): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Update agent',
+      opUpdateAgent({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  // ── Event handlers (DSL handler registry) ────────────────────────────
+
+  /**
+   * Register a tenant-configurable event handler — DSL row in the
+   * `event_handlers` table that drives `create-event-block` for event
+   * types not covered by a Python handler. Match selectors plus a
+   * `transaction_template` describing the GL rows to produce.
+   */
+  async createEventHandler(
+    graphId: string,
+    body: CreateEventHandlerRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Create event handler',
+      opCreateEventHandler({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  /**
+   * Update a registered event handler. Pass `approve: true` to flip an
+   * AI-suggested handler from unapproved to active.
+   */
+  async updateEventHandler(
+    graphId: string,
+    body: UpdateEventHandlerRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Update event handler',
+      opUpdateEventHandler({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  // ── Financial statements (graph-backed) ──────────────────────────────
+
+  /**
+   * Live financial statement — pulls facts directly from the graph for
+   * an explicit period window (or fiscal year) and returns the statement
+   * shape without a persisted Report row. Useful for ad-hoc previews and
+   * dashboards.
+   */
+  async liveFinancialStatement(
+    graphId: string,
+    body: LiveFinancialStatementRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Live financial statement',
+      opLiveFinancialStatement({ path: { graph_id: graphId }, body })
+    )
+    return (envelope.result ?? {}) as Record<string, unknown>
+  }
+
+  /**
+   * Run a financial statement analysis against an existing report.
+   * On shared-repo graphs (e.g. SEC), `ticker` is required; on tenant
+   * graphs it's ignored. Either pass an explicit `report_id` or let the
+   * server auto-resolve via `fiscal_year` + `period_type`.
+   */
+  async financialStatementAnalysis(
+    graphId: string,
+    body: FinancialStatementAnalysisRequest
+  ): Promise<Record<string, unknown>> {
+    const envelope = await this.callOperation(
+      'Financial statement analysis',
+      opFinancialStatementAnalysis({ path: { graph_id: graphId }, body })
     )
     return (envelope.result ?? {}) as Record<string, unknown>
   }
@@ -1814,20 +1758,6 @@ export class LedgerClient {
 
 // ── Module-private conversion helpers ─────────────────────────────────
 
-function rawToClosingEntry(data: RawClosingEntryResult): ClosingEntry {
-  return {
-    outcome: data.outcome,
-    entryId: data.entry_id ?? null,
-    status: data.status ?? null,
-    postingDate: data.posting_date ?? null,
-    memo: data.memo ?? null,
-    debitElementId: data.debit_element_id ?? null,
-    creditElementId: data.credit_element_id ?? null,
-    amount: data.amount ?? null,
-    reason: data.reason ?? null,
-  }
-}
-
 function rawFiscalCalendarToCamel(raw: RawFiscalCalendar): LedgerFiscalCalendar {
   return {
     graphId: raw.graph_id,