@robosystems/client 1.11.0 → 1.12.1

package/sdk/types.gen.ts

@@ -712,6 +712,12 @@ export type BackfillPlanHistoryOperation = {
      * Override the stranded-obligation gate on each reclose. Only needed when a matured classified obligation without a drafted entry exists inside the backfill window and you have decided not to draft or void it first.
      */
     allow_stranded_obligations?: boolean;
+    /**
+     * Allow Reconciling Items
+     *
+     * Override the reconciling-item gate on each reclose. Only needed when an event inside the backfill window is still flagged as changed upstream and you have decided not to resolve it first.
+     */
+    allow_reconciling_items?: boolean;
     /**
      * Restamp
      *
@@ -1663,6 +1669,12 @@ export type ClosePeriodOperation = {
      * Override the stranded-obligation gate — close even though matured classified obligations have no drafted closing entry, knowingly omitting those adjusting entries from the period. Prefer running promote-obligations with dispatch_handlers=true (which drafts them) or voiding the obligations instead. The override is recorded in the close audit note.
      */
     allow_stranded_obligations?: boolean;
+    /**
+     * Allow Reconciling Items
+     *
+     * Override the reconciling-item gate — close even though posted events in the period are still flagged as changed in the source system, leaving those differences undecided. The next sync will still report them, and the statements stamped by this close may disagree with the source. Prefer resolve-reconciling-item on each first. The override is recorded in the close audit note.
+     */
+    allow_reconciling_items?: boolean;
     /**
      * Period
      *
@@ -4184,7 +4196,7 @@ export type DeleteSubgraphOp = {
     /**
      * Backup First
      *
-     * Create a backup before deleting
+     * Take a full backup of the subgraph before deleting it. The backup is registered on the parent graph's backup list, where it can be listed and downloaded after the subgraph is gone. If the backup fails the subgraph is not deleted.
      */
     backup_first?: boolean;
 };
@@ -4653,15 +4665,15 @@ export type ElementSummary = {
     /**
      * Total
      *
-     * Sum of values across the returned facts
+     * Sum of values across the returned facts. Duration elements only — a balance summed across periods is not a balance, so instants omit it.
      */
-    total: number;
+    total?: number | null;
     /**
      * Average
      *
-     * Mean value across the returned facts
+     * Mean value across the returned facts. Duration elements only; omitted for instants.
      */
-    average: number;
+    average?: number | null;
     /**
      * Min
      *
@@ -5863,6 +5875,18 @@ export type FiscalCalendarResponse = {
      * Sample of up to 5 stranded obligations (schedule_id, schedule_name, period, event_id) ordered by occurred_at.
      */
     stranded_obligation_sample?: Array<PendingObligationDetailResponse>;
+    /**
+     * Reconciling Item Count
+     *
+     * Posted events in or before this period whose source payload changed afterwards and that nobody has dispositioned — differences between the books and the source system. Resolve each with resolve-reconciling-item, or close over them knowingly with allow_reconciling_items.
+     */
+    reconciling_item_count?: number;
+    /**
+     * Reconciling Item Sample
+     *
+     * Source identifiers (or event ids) of up to 5 unresolved reconciling items, so the blocker names what is holding the close.
+     */
+    reconciling_item_sample?: Array<string>;
     /**
      * Last Close At
      */
@@ -8513,7 +8537,7 @@ export type LiveFinancialStatementRequest = {
     /**
      * Statement Type
      *
-     * income_statement | balance_sheet | cash_flow_statement | equity_statement
+     * income_statement | balance_sheet | cash_flow_statement | equity_statement. ``equity_statement`` is provisional — equity balances, not a rollforward — and is not offered on the MCP surface until it articulates.
      */
     statement_type: string;
     /**
@@ -8543,7 +8567,7 @@ export type LiveFinancialStatementRequest = {
     /**
      * Limit
      *
-     * Max fact rows returned
+     * Max fact rows returned. Defaults to the ceiling so a statement is never cut mid-section — visible rows would stop footing to visible subtotals. Lower it only for a preview.
      */
     limit?: number;
 };
@@ -8564,6 +8588,8 @@ export type LiveFinancialStatementResponse = {
     statement_type: string;
     /**
      * Periods
+     *
+     * Rendered columns, aligned with each row's ``values``. Current and prior for income_statement and balance_sheet; current only for cash_flow_statement — the prior period is pivoted as the indirect-method delta basis and not rendered.
      */
     periods: Array<PeriodSpec>;
     /**
@@ -8574,6 +8600,10 @@ export type LiveFinancialStatementResponse = {
      * Fact Count
      */
     fact_count: number;
+    /**
+     * Guard-rail outcome for the rendered columns — accounting equation, net-income equation, totals footing, operating-plug size. Null only when no structure rendered.
+     */
+    validation?: ValidationCheckResponse | null;
     /**
      * Unmapped Count
      */
@@ -8636,50 +8666,6 @@ export type LoginRequest = {
     password: string;
 };
 
-/**
- * MCPToolCall
- *
- * Request model for MCP tool execution.
- */
-export type McpToolCall = {
-    /**
-     * Name
-     *
-     * Name of the MCP tool to execute
-     */
-    name: string;
-    /**
-     * Arguments
-     *
-     * Arguments to pass to the tool
-     */
-    arguments?: {
-        [key: string]: unknown;
-    };
-};
-
-/**
- * MCPToolsResponse
- *
- * Response model for MCP tools listing.
- */
-export type McpToolsResponse = {
-    /**
-     * Tools
-     *
-     * List of available MCP tools with their schemas
-     */
-    tools: Array<{
-        [key: string]: unknown;
-    }>;
-    /**
-     * Instructions
-     *
-     * Per-graph routing guidance for MCP clients, tailored to the graph's category and live tool set. Clients should pass this to the MCP server's `instructions` handshake field so it is always in the agent's context.
-     */
-    instructions?: string | null;
-};
-
 /**
  * MaterializeOp
  *
@@ -9027,6 +9013,88 @@ export type OAuthCallbackResponse = {
     auto_sync_task_id?: string | null;
 };
 
+/**
+ * OAuthGrantInfo
+ *
+ * A connected app: one OAuth consent for one client on one graph.
+ */
+export type OAuthGrantInfo = {
+    /**
+     * Id
+     *
+     * Grant ID
+     */
+    id: string;
+    /**
+     * Client Name
+     *
+     * The connected client's display name
+     */
+    client_name: string;
+    /**
+     * Client Uri
+     *
+     * The client's homepage, if declared
+     */
+    client_uri?: string | null;
+    /**
+     * Client Is Trusted
+     *
+     * Whether the client is on the trusted list (pre-registered, or a known metadata-document host). Untrusted clients registered themselves.
+     */
+    client_is_trusted: boolean;
+    /**
+     * Graph Id
+     *
+     * The one graph this consent reaches
+     */
+    graph_id: string;
+    /**
+     * Graph Name
+     *
+     * The graph's display name, when the graph still exists
+     */
+    graph_name?: string | null;
+    /**
+     * Resource
+     *
+     * The MCP URL the grant's tokens are bound to (their audience)
+     */
+    resource: string;
+    /**
+     * Scope
+     *
+     * Granted scopes, space-separated
+     */
+    scope: string;
+    /**
+     * Created At
+     *
+     * When the user consented
+     */
+    created_at: string;
+    /**
+     * Last Used At
+     *
+     * Last token use, if any
+     */
+    last_used_at?: string | null;
+};
+
+/**
+ * OAuthGrantsResponse
+ *
+ * Response model for listing connected apps.
+ */
+export type OAuthGrantsResponse = {
+    /**
+     * Grants
+     *
+     * Active OAuth grants, newest first
+     */
+    grants: Array<OAuthGrantInfo>;
+};
+
 /**
  * OAuthInitRequest
  *
@@ -10732,6 +10800,52 @@ export type OperationEnvelopePublishListResponse = {
     idempotentReplay?: boolean;
 };
 
+/**
+ * OperationEnvelope[ReconcilingItemPlan]
+ */
+export type OperationEnvelopeReconcilingItemPlan = {
+    /**
+     * Operation
+     *
+     * Kebab-case operation name
+     */
+    operation: string;
+    /**
+     * Operationid
+     *
+     * op_-prefixed ULID for audit and SSE correlation
+     */
+    operationId: string;
+    /**
+     * Status
+     *
+     * Operation lifecycle state
+     */
+    status: 'completed' | 'pending' | 'failed';
+    /**
+     * Command-specific result payload
+     */
+    result?: ReconcilingItemPlan | null;
+    /**
+     * At
+     *
+     * ISO-8601 UTC timestamp
+     */
+    at: string;
+    /**
+     * Createdby
+     *
+     * User ID that initiated the operation (null for legacy callers)
+     */
+    createdBy?: string | null;
+    /**
+     * Idempotentreplay
+     *
+     * True when this envelope came from the idempotency cache — the underlying command did not execute again. False on fresh executions.
+     */
+    idempotentReplay?: boolean;
+};
+
 /**
  * OperationEnvelope[ReportResponse]
  */
@@ -10778,6 +10892,52 @@ export type OperationEnvelopeReportResponse = {
     idempotentReplay?: boolean;
 };
 
+/**
+ * OperationEnvelope[ResolveReconcilingItemResponse]
+ */
+export type OperationEnvelopeResolveReconcilingItemResponse = {
+    /**
+     * Operation
+     *
+     * Kebab-case operation name
+     */
+    operation: string;
+    /**
+     * Operationid
+     *
+     * op_-prefixed ULID for audit and SSE correlation
+     */
+    operationId: string;
+    /**
+     * Status
+     *
+     * Operation lifecycle state
+     */
+    status: 'completed' | 'pending' | 'failed';
+    /**
+     * Command-specific result payload
+     */
+    result?: ResolveReconcilingItemResponse | null;
+    /**
+     * At
+     *
+     * ISO-8601 UTC timestamp
+     */
+    at: string;
+    /**
+     * Createdby
+     *
+     * User ID that initiated the operation (null for legacy callers)
+     */
+    createdBy?: string | null;
+    /**
+     * Idempotentreplay
+     *
+     * True when this envelope came from the idempotency cache — the underlying command did not execute again. False on fresh executions.
+     */
+    idempotentReplay?: boolean;
+};
+
 /**
  * OperationEnvelope[RevokeReportShareResponse]
  */
@@ -11148,6 +11308,22 @@ export type OperationEnvelopeListPublishListMemberResponse = {
     idempotentReplay?: boolean;
 };
 
+/**
+ * OperationResumeRequest
+ *
+ * Answer for an operation paused at a checkpoint (`awaiting_input`).
+ */
+export type OperationResumeRequest = {
+    /**
+     * Input
+     *
+     * The decision the paused run asked for, in whatever shape its prompt described. Delivered to the task as `params['resume']['input']`.
+     */
+    input?: {
+        [key: string]: unknown;
+    };
+};
+
 /**
  * OperatorListResponse
  *
@@ -11319,6 +11495,12 @@ export type OperatorRequest = {
      * Enable streaming response
      */
     stream?: boolean;
+    /**
+     * Max Credits
+     *
+     * Per-question credit ceiling. Once the run's consumed credits reach this number, no further tool step starts and the operator answers from what it has (the wrap-up itself may carry the total slightly past the ceiling). Omit for the mode's default step-bounded behavior.
+     */
+    max_credits?: number | null;
 };
 
 /**
@@ -12631,6 +12813,20 @@ export type PreviewEventBlockResponse = {
     };
 };
 
+/**
+ * PreviewReconcilingItemRequest
+ *
+ * Read what changed on a reconciling item, and what resolving it would do.
+ */
+export type PreviewReconcilingItemRequest = {
+    /**
+     * Event Id
+     *
+     * Event id (evt_ prefixed) to inspect
+     */
+    event_id: string;
+};
+
 /**
  * PromoteObligationsRequest
  *
@@ -12905,55 +13101,283 @@ export type RebuildScheduleRequest = {
 };
 
 /**
- * RecoveryCodesRequest
+ * ReconcilingItemCatchUp
  *
- * Re-authentication proof for regenerating recovery codes.
+ * The catch-up entry a resolution posted.
  */
-export type RecoveryCodesRequest = {
+export type ReconcilingItemCatchUp = {
     /**
-     * Password
-     *
-     * Current password (password-holding users)
+     * Event Id
      */
-    password?: string | null;
+    event_id: string;
     /**
-     * Assertion
-     *
-     * Fresh WebAuthn assertion from the re-auth ceremony
+     * Entry Id
      */
-    assertion?: {
-        [key: string]: unknown;
-    } | null;
-};
-
-/**
- * RecoveryCodesResponse
- *
- * A fresh recovery-code set — shown exactly once.
- */
-export type RecoveryCodesResponse = {
+    entry_id?: string | null;
     /**
-     * Codes
-     *
-     * Single-use recovery codes
+     * Transaction Id
      */
-    codes: Array<string>;
+    transaction_id?: string | null;
+    /**
+     * Posting Date
+     */
+    posting_date: string;
+    /**
+     * Status
+     */
+    status: string;
 };
 
 /**
- * RegenerateReportOperation
+ * ReconcilingItemDeltaLine
  *
- * Regenerate facts for an existing Report. Carries `report_id` from
- * the path-style RPC body; period overrides are inherited from
- * :class:`RegenerateReportRequest`.
+ * One account's net change between the posted entries and the new payload.
+ *
+ * Amounts are signed minor units in debit-positive convention: a positive
+ * figure is a net debit, a negative one a net credit. ``delta`` is what a
+ * catch-up entry would post to bring the books level.
  */
-export type RegenerateReportOperation = {
+export type ReconcilingItemDeltaLine = {
     /**
-     * Period Start
+     * Element Id
      *
-     * New current-period start. Optional — omit to keep the existing window.
+     * CoA element id; null when the account is unmapped
      */
-    period_start?: string | null;
+    element_id?: string | null;
+    /**
+     * Element External Id
+     *
+     * Source-system account id, when the line carried one
+     */
+    element_external_id?: string | null;
+    /**
+     * Element Code
+     *
+     * Account code
+     */
+    element_code?: string | null;
+    /**
+     * Element Name
+     *
+     * Account name
+     */
+    element_name?: string | null;
+    /**
+     * Prior Net
+     *
+     * Net of the posted entries, debit-positive
+     */
+    prior_net: number;
+    /**
+     * Accepted Net
+     *
+     * Net of the new payload, debit-positive
+     */
+    accepted_net: number;
+    /**
+     * Delta
+     *
+     * accepted_net - prior_net
+     */
+    delta: number;
+};
+
+/**
+ * ReconcilingItemEntrySummary
+ *
+ * One entry on either side of the comparison.
+ */
+export type ReconcilingItemEntrySummary = {
+    /**
+     * Entry Id
+     *
+     * Entry id; null for the accepted side, which is not posted yet
+     */
+    entry_id?: string | null;
+    /**
+     * External Id
+     */
+    external_id?: string | null;
+    /**
+     * Posting Date
+     */
+    posting_date?: string | null;
+    /**
+     * Memo
+     */
+    memo?: string | null;
+    /**
+     * Status
+     *
+     * Entry status; null on the accepted side
+     */
+    status?: string | null;
+    /**
+     * Total Debit
+     */
+    total_debit?: number;
+    /**
+     * Total Credit
+     */
+    total_credit?: number;
+};
+
+/**
+ * ReconcilingItemPlan
+ *
+ * What changed upstream, and what each disposition would do about it.
+ */
+export type ReconcilingItemPlan = {
+    /**
+     * Event Id
+     */
+    event_id: string;
+    /**
+     * External Id
+     */
+    external_id?: string | null;
+    /**
+     * Source
+     */
+    source: string;
+    /**
+     * Event Type
+     */
+    event_type: string;
+    /**
+     * Event Status
+     */
+    event_status: string;
+    /**
+     * Drift Detected At
+     *
+     * When the sync first saw this difference
+     */
+    drift_detected_at?: string | null;
+    /**
+     * Default Disposition
+     *
+     * What resolve would do with no disposition given: restate while every affected period is open, catch_up once one is closed.
+     */
+    default_disposition: 'restate' | 'catch_up' | 'acknowledge';
+    /**
+     * Default Posting Date
+     *
+     * Where a catch-up entry would land by default
+     */
+    default_posting_date?: string | null;
+    /**
+     * Affected Posting Dates
+     *
+     * Posting dates of the event's entries
+     */
+    affected_posting_dates?: Array<string>;
+    /**
+     * Closed Periods
+     *
+     * Names of closed periods the event's entries sit in
+     */
+    closed_periods?: Array<string>;
+    /**
+     * Prior Entries
+     */
+    prior_entries?: Array<ReconcilingItemEntrySummary>;
+    /**
+     * Accepted Entries
+     */
+    accepted_entries?: Array<ReconcilingItemEntrySummary>;
+    /**
+     * Delta
+     *
+     * Per-account net change; empty when none
+     */
+    delta?: Array<ReconcilingItemDeltaLine>;
+    /**
+     * No Gl Effect
+     *
+     * The change moves no money — a memo or reference edit. catch_up posts nothing; restate still regenerates so the entries carry the new text.
+     */
+    no_gl_effect?: boolean;
+    /**
+     * Restate Blockers
+     *
+     * Why restate is unavailable, if it is: a closed period, an entry that was reversed or is not posted, or entries from elsewhere sharing this event's transaction.
+     */
+    restate_blockers?: Array<string>;
+    /**
+     * Unmapped Element External Ids
+     *
+     * Accounts in the new payload with no mapping in this graph. Both dispositions that write need them mapped first.
+     */
+    unmapped_element_external_ids?: Array<string>;
+};
+
+/**
+ * ReconcilingItemRegenerated
+ *
+ * The entries a restate rebuilt.
+ */
+export type ReconcilingItemRegenerated = {
+    /**
+     * Transaction Ids
+     */
+    transaction_ids?: Array<string>;
+    /**
+     * Entry Ids
+     */
+    entry_ids?: Array<string>;
+};
+
+/**
+ * RecoveryCodesRequest
+ *
+ * Re-authentication proof for regenerating recovery codes.
+ */
+export type RecoveryCodesRequest = {
+    /**
+     * Password
+     *
+     * Current password (password-holding users)
+     */
+    password?: string | null;
+    /**
+     * Assertion
+     *
+     * Fresh WebAuthn assertion from the re-auth ceremony
+     */
+    assertion?: {
+        [key: string]: unknown;
+    } | null;
+};
+
+/**
+ * RecoveryCodesResponse
+ *
+ * A fresh recovery-code set — shown exactly once.
+ */
+export type RecoveryCodesResponse = {
+    /**
+     * Codes
+     *
+     * Single-use recovery codes
+     */
+    codes: Array<string>;
+};
+
+/**
+ * RegenerateReportOperation
+ *
+ * Regenerate facts for an existing Report. Carries `report_id` from
+ * the path-style RPC body; period overrides are inherited from
+ * :class:`RegenerateReportRequest`.
+ */
+export type RegenerateReportOperation = {
+    /**
+     * Period Start
+     *
+     * New current-period start. Optional — omit to keep the existing window.
+     */
+    period_start?: string | null;
     /**
      * Period End
      *
@@ -13494,6 +13918,102 @@ export type ResetPasswordValidateResponse = {
     email?: string | null;
 };
 
+/**
+ * ResolveReconcilingItemRequest
+ *
+ * Dispose of one reconciling item and clear its flag.
+ */
+export type ResolveReconcilingItemRequest = {
+    /**
+     * Event Id
+     *
+     * Event id (evt_ prefixed) to resolve
+     */
+    event_id: string;
+    /**
+     * Disposition
+     *
+     * How to dispose of the difference. Omit to take the default the preview reports: restate when every period the event touches is open, catch_up when any is closed.
+     */
+    disposition?: 'restate' | 'catch_up' | 'acknowledge' | null;
+    /**
+     * Posting Date
+     *
+     * catch_up only: when to post the catch-up entry. Defaults to the end of the earliest open period.
+     */
+    posting_date?: string | null;
+    /**
+     * Status
+     *
+     * catch_up only: whether the catch-up entry is drafted for review at close (default) or posted immediately. A draft appears in list-period-drafts and posts locally when the period closes.
+     */
+    status?: 'draft' | 'posted';
+    /**
+     * Note
+     *
+     * Why this disposition. Required for acknowledge, where it is the only record of what was done instead.
+     */
+    note?: string | null;
+    /**
+     * Reference Event Id
+     *
+     * acknowledge only: the event that already handled this difference (e.g. an alignment entry authored by hand), recorded on the trail.
+     */
+    reference_event_id?: string | null;
+};
+
+/**
+ * ResolveReconcilingItemResponse
+ *
+ * The outcome of resolving one reconciling item.
+ */
+export type ResolveReconcilingItemResponse = {
+    /**
+     * Event Id
+     */
+    event_id: string;
+    /**
+     * External Id
+     */
+    external_id?: string | null;
+    /**
+     * Disposition
+     */
+    disposition: 'restate' | 'catch_up' | 'acknowledge';
+    /**
+     * Delta
+     */
+    delta?: Array<ReconcilingItemDeltaLine>;
+    /**
+     * No Gl Effect
+     */
+    no_gl_effect?: boolean;
+    /**
+     * Present when the disposition posted a catch-up entry
+     */
+    catch_up?: ReconcilingItemCatchUp | null;
+    /**
+     * Present when the disposition rebuilt the event's entries
+     */
+    regenerated?: ReconcilingItemRegenerated | null;
+    /**
+     * Reference Event Id
+     */
+    reference_event_id?: string | null;
+    /**
+     * Note
+     */
+    note?: string | null;
+    /**
+     * Resolved At
+     */
+    resolved_at: string;
+    /**
+     * Resolved By
+     */
+    resolved_by: string;
+};
+
 /**
  * ResolvedReportInfo
  *
@@ -17136,6 +17656,48 @@ export type UserResponse = {
     accounts?: Array<AccountInfo>;
 };
 
+/**
+ * ValidationCheckResponse
+ *
+ * Aggregate result of running reporting rules over a structure.
+ *
+ * Every rule runs once per rendered period column; on a multi-column
+ * statement each failure and warning is prefixed with the column it was
+ * found in (``[Prior] …``).
+ */
+export type ValidationCheckResponse = {
+    /**
+     * Passed
+     *
+     * True iff at least one rule ran and every rule produced zero failures on every rendered column. False when nothing was checked (`status == 'inconclusive'`).
+     */
+    passed: boolean;
+    /**
+     * Status
+     *
+     * `passed` — every rule ran on every column with zero failures; `failed` — at least one rule failed; `inconclusive` — no validation rules exist for this block type, so nothing was checked.
+     */
+    status: string;
+    /**
+     * Checks
+     *
+     * Names of rules that were evaluated.
+     */
+    checks: Array<string>;
+    /**
+     * Failures
+     *
+     * Human-readable descriptions of rule failures.
+     */
+    failures: Array<string>;
+    /**
+     * Warnings
+     *
+     * Non-blocking advisories from rule evaluation.
+     */
+    warnings: Array<string>;
+};
+
 /**
  * ValidationError
  */
@@ -17179,6 +17741,10 @@ export type ValidationLite = {
      * Passed
      */
     passed?: boolean;
+    /**
+     * Status
+     */
+    status?: string;
     /**
      * Checks
      */
@@ -17470,7 +18036,7 @@ export type ViewResponse = {
     /**
      * Summary
      *
-     * Per-element aggregates, only when include_summary=true. Note that `total` sums across every returned period, which is meaningful for duration facts and not for instants. Overlapping duration windows sharing a period_end (quarter + year-to-date) contribute only the narrowest window, so a quarter is never double-counted inside its own YTD figure.
+     * Per-element aggregates, only when include_summary=true. `total` and `average` span every returned period, so they are present for duration elements only — instants omit both (a balance summed across periods is not a balance). Overlapping duration windows sharing a period_end (quarter + year-to-date) contribute only the narrowest window, so a quarter is never double-counted inside its own YTD figure.
      */
     summary?: {
         [key: string]: ElementSummary;
@@ -19225,6 +19791,101 @@ export type UpdateUserApiKeyResponses = {
 
 export type UpdateUserApiKeyResponse = UpdateUserApiKeyResponses[keyof UpdateUserApiKeyResponses];
 
+export type ListUserOAuthGrantsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/user/oauth/grants';
+};
+
+export type ListUserOAuthGrantsErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Access denied
+     */
+    403: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+
+export type ListUserOAuthGrantsError = ListUserOAuthGrantsErrors[keyof ListUserOAuthGrantsErrors];
+
+export type ListUserOAuthGrantsResponses = {
+    /**
+     * Successful Response
+     */
+    200: OAuthGrantsResponse;
+};
+
+export type ListUserOAuthGrantsResponse = ListUserOAuthGrantsResponses[keyof ListUserOAuthGrantsResponses];
+
+export type RevokeUserOAuthGrantData = {
+    body?: never;
+    path: {
+        /**
+         * Grant Id
+         */
+        grant_id: string;
+    };
+    query?: never;
+    url: '/v1/user/oauth/grants/{grant_id}';
+};
+
+export type RevokeUserOAuthGrantErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Access denied
+     */
+    403: ErrorResponse;
+    /**
+     * Resource not found
+     */
+    404: ErrorResponse;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+
+export type RevokeUserOAuthGrantError = RevokeUserOAuthGrantErrors[keyof RevokeUserOAuthGrantErrors];
+
+export type RevokeUserOAuthGrantResponses = {
+    /**
+     * Successful Response
+     */
+    200: SuccessResponse;
+};
+
+export type RevokeUserOAuthGrantResponse = RevokeUserOAuthGrantResponses[keyof RevokeUserOAuthGrantResponses];
+
 export type ListUserOrgsData = {
     body?: never;
     path?: never;
@@ -20493,162 +21154,33 @@ export type SetConnectionWritePolicyError = SetConnectionWritePolicyErrors[keyof
 
 export type SetConnectionWritePolicyResponses = {
     /**
-     * Successful Response
-     */
-    200: ConnectionResponse;
-};
-
-export type SetConnectionWritePolicyResponse = SetConnectionWritePolicyResponses[keyof SetConnectionWritePolicyResponses];
-
-export type ListOperatorsData = {
-    body?: never;
-    path: {
-        /**
-         * Graph Id
-         */
-        graph_id: string;
-    };
-    query?: {
-        /**
-         * Capability
-         *
-         * Filter by capability (e.g., 'financial_analysis', 'rag_search')
-         */
-        capability?: string | null;
-    };
-    url: '/v1/graphs/{graph_id}/operator';
-};
-
-export type ListOperatorsErrors = {
-    /**
-     * Invalid request
-     */
-    400: ErrorResponse;
-    /**
-     * Authentication required
-     */
-    401: ErrorResponse;
-    /**
-     * Access denied
-     */
-    403: ErrorResponse;
-    /**
-     * Resource not found
-     */
-    404: ErrorResponse;
-    /**
-     * Validation Error
-     */
-    422: HttpValidationError;
-    /**
-     * Rate limit exceeded
-     */
-    429: ErrorResponse;
-    /**
-     * Internal server error
-     */
-    500: ErrorResponse;
-};
-
-export type ListOperatorsError = ListOperatorsErrors[keyof ListOperatorsErrors];
-
-export type ListOperatorsResponses = {
-    /**
-     * Successful Response
-     */
-    200: OperatorListResponse;
-};
-
-export type ListOperatorsResponse = ListOperatorsResponses[keyof ListOperatorsResponses];
-
-export type AutoSelectOperatorData = {
-    body: OperatorRequest;
-    path: {
-        /**
-         * Graph Id
-         */
-        graph_id: string;
-    };
-    query?: {
-        /**
-         * Mode
-         *
-         * Override execution mode: sync, async, stream, or auto
-         */
-        mode?: ResponseMode | null;
-    };
-    url: '/v1/graphs/{graph_id}/operator';
-};
-
-export type AutoSelectOperatorErrors = {
-    /**
-     * Invalid request
-     */
-    400: ErrorResponse;
-    /**
-     * Authentication required
-     */
-    401: ErrorResponse;
-    /**
-     * Insufficient credits
-     */
-    402: unknown;
-    /**
-     * Access denied
-     */
-    403: ErrorResponse;
-    /**
-     * Resource not found
-     */
-    404: ErrorResponse;
-    /**
-     * Validation Error
-     */
-    422: HttpValidationError;
-    /**
-     * Rate limit exceeded
-     */
-    429: ErrorResponse;
-    /**
-     * Internal server error
-     */
-    500: ErrorResponse;
-};
-
-export type AutoSelectOperatorError = AutoSelectOperatorErrors[keyof AutoSelectOperatorErrors];
-
-export type AutoSelectOperatorResponses = {
-    /**
-     * Successful Response
-     */
-    200: OperatorResponse;
-    /**
-     * Query queued for async processing
+     * Successful Response
      */
-    202: unknown;
+    200: ConnectionResponse;
 };
 
-export type AutoSelectOperatorResponse = AutoSelectOperatorResponses[keyof AutoSelectOperatorResponses];
+export type SetConnectionWritePolicyResponse = SetConnectionWritePolicyResponses[keyof SetConnectionWritePolicyResponses];
 
-export type GetOperatorMetadataData = {
+export type ListOperatorsData = {
     body?: never;
     path: {
         /**
          * Graph Id
          */
         graph_id: string;
+    };
+    query?: {
         /**
-         * Operator Type
+         * Capability
          *
-         * Operator type identifier (e.g., 'financial', 'research', 'rag')
+         * Filter by capability (e.g., 'financial_analysis', 'rag_search')
          */
-        operator_type: string;
+        capability?: string | null;
     };
-    query?: never;
-    url: '/v1/graphs/{graph_id}/operator/{operator_type}';
+    url: '/v1/graphs/{graph_id}/operator';
 };
 
-export type GetOperatorMetadataErrors = {
+export type ListOperatorsErrors = {
     /**
      * Invalid request
      */
@@ -20679,24 +21211,20 @@ export type GetOperatorMetadataErrors = {
     500: ErrorResponse;
 };
 
-export type GetOperatorMetadataError = GetOperatorMetadataErrors[keyof GetOperatorMetadataErrors];
+export type ListOperatorsError = ListOperatorsErrors[keyof ListOperatorsErrors];
 
-export type GetOperatorMetadataResponses = {
+export type ListOperatorsResponses = {
     /**
      * Successful Response
      */
-    200: OperatorMetadataResponse;
+    200: OperatorListResponse;
 };
 
-export type GetOperatorMetadataResponse = GetOperatorMetadataResponses[keyof GetOperatorMetadataResponses];
+export type ListOperatorsResponse = ListOperatorsResponses[keyof ListOperatorsResponses];
 
-export type ExecuteSpecificOperatorData = {
+export type AutoSelectOperatorData = {
     body: OperatorRequest;
     path: {
-        /**
-         * Operator Type
-         */
-        operator_type: string;
         /**
          * Graph Id
          */
@@ -20706,14 +21234,14 @@ export type ExecuteSpecificOperatorData = {
         /**
          * Mode
          *
-         * Override execution mode: sync, async, stream, or auto
+         * `sync` waits up to 50s for the answer and returns 200 with it (202 with the operation links if the worker is still busy). Anything else — `async`, `stream`, `auto` or unset — queues the run and returns 202; follow `_links.stream` for progress and the result.
          */
         mode?: ResponseMode | null;
     };
-    url: '/v1/graphs/{graph_id}/operator/{operator_type}';
+    url: '/v1/graphs/{graph_id}/operator';
 };
 
-export type ExecuteSpecificOperatorErrors = {
+export type AutoSelectOperatorErrors = {
     /**
      * Invalid request
      */
@@ -20748,34 +21276,40 @@ export type ExecuteSpecificOperatorErrors = {
     500: ErrorResponse;
 };
 
-export type ExecuteSpecificOperatorError = ExecuteSpecificOperatorErrors[keyof ExecuteSpecificOperatorErrors];
+export type AutoSelectOperatorError = AutoSelectOperatorErrors[keyof AutoSelectOperatorErrors];
 
-export type ExecuteSpecificOperatorResponses = {
+export type AutoSelectOperatorResponses = {
     /**
      * Successful Response
      */
     200: OperatorResponse;
     /**
-     * Query queued for async processing
+     * Run queued on the worker — follow `_links.stream`
      */
     202: unknown;
 };
 
-export type ExecuteSpecificOperatorResponse = ExecuteSpecificOperatorResponses[keyof ExecuteSpecificOperatorResponses];
+export type AutoSelectOperatorResponse = AutoSelectOperatorResponses[keyof AutoSelectOperatorResponses];
 
-export type ListMcpToolsData = {
+export type GetOperatorMetadataData = {
     body?: never;
     path: {
         /**
          * Graph Id
          */
         graph_id: string;
+        /**
+         * Operator Type
+         *
+         * Operator type identifier (e.g., 'financial', 'research', 'rag')
+         */
+        operator_type: string;
     };
     query?: never;
-    url: '/v1/graphs/{graph_id}/mcp/tools';
+    url: '/v1/graphs/{graph_id}/operator/{operator_type}';
 };
 
-export type ListMcpToolsErrors = {
+export type GetOperatorMetadataErrors = {
     /**
      * Invalid request
      */
@@ -20806,20 +21340,24 @@ export type ListMcpToolsErrors = {
     500: ErrorResponse;
 };
 
-export type ListMcpToolsError = ListMcpToolsErrors[keyof ListMcpToolsErrors];
+export type GetOperatorMetadataError = GetOperatorMetadataErrors[keyof GetOperatorMetadataErrors];
 
-export type ListMcpToolsResponses = {
+export type GetOperatorMetadataResponses = {
     /**
      * Successful Response
      */
-    200: McpToolsResponse;
+    200: OperatorMetadataResponse;
 };
 
-export type ListMcpToolsResponse = ListMcpToolsResponses[keyof ListMcpToolsResponses];
+export type GetOperatorMetadataResponse = GetOperatorMetadataResponses[keyof GetOperatorMetadataResponses];
 
-export type CallMcpToolData = {
-    body: McpToolCall;
+export type ExecuteSpecificOperatorData = {
+    body: OperatorRequest;
     path: {
+        /**
+         * Operator Type
+         */
+        operator_type: string;
         /**
          * Graph Id
          */
@@ -20827,22 +21365,16 @@ export type CallMcpToolData = {
     };
     query?: {
         /**
-         * Format
-         *
-         * Response format override (json, sse, ndjson)
-         */
-        format?: string | null;
-        /**
-         * Test Mode
+         * Mode
          *
-         * Enable test mode for debugging
+         * `sync` waits up to 50s for the answer and returns 200 with it (202 with the operation links if the worker is still busy). Anything else — `async`, `stream`, `auto` or unset — queues the run and returns 202; follow `_links.stream` for progress and the result.
          */
-        test_mode?: boolean;
+        mode?: ResponseMode | null;
     };
-    url: '/v1/graphs/{graph_id}/mcp/call-tool';
+    url: '/v1/graphs/{graph_id}/operator/{operator_type}';
 };
 
-export type CallMcpToolErrors = {
+export type ExecuteSpecificOperatorErrors = {
     /**
      * Invalid request
      */
@@ -20851,6 +21383,10 @@ export type CallMcpToolErrors = {
      * Authentication required
      */
     401: ErrorResponse;
+    /**
+     * Insufficient credits
+     */
+    402: unknown;
     /**
      * Access denied
      */
@@ -20859,10 +21395,6 @@ export type CallMcpToolErrors = {
      * Resource not found
      */
     404: ErrorResponse;
-    /**
-     * Execution timeout
-     */
-    408: unknown;
     /**
      * Validation Error
      */
@@ -20875,25 +21407,23 @@ export type CallMcpToolErrors = {
      * Internal server error
      */
     500: ErrorResponse;
-    /**
-     * Service unavailable
-     */
-    503: unknown;
 };
 
-export type CallMcpToolError = CallMcpToolErrors[keyof CallMcpToolErrors];
+export type ExecuteSpecificOperatorError = ExecuteSpecificOperatorErrors[keyof ExecuteSpecificOperatorErrors];
 
-export type CallMcpToolResponses = {
+export type ExecuteSpecificOperatorResponses = {
     /**
      * Successful Response
      */
-    200: unknown;
+    200: OperatorResponse;
     /**
-     * Tool queued for execution
+     * Run queued on the worker — follow `_links.stream`
      */
     202: unknown;
 };
 
+export type ExecuteSpecificOperatorResponse = ExecuteSpecificOperatorResponses[keyof ExecuteSpecificOperatorResponses];
+
 export type ListBackupsData = {
     body?: never;
     path: {
@@ -24512,6 +25042,70 @@ export type CancelOperationResponses = {
 
 export type CancelOperationResponse = CancelOperationResponses[keyof CancelOperationResponses];
 
+export type ResumeOperationData = {
+    body: OperationResumeRequest;
+    path: {
+        /**
+         * Operation Id
+         *
+         * Operation identifier
+         */
+        operation_id: string;
+    };
+    query?: never;
+    url: '/v1/operations/{operation_id}/resume';
+};
+
+export type ResumeOperationErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Access denied
+     */
+    403: ErrorResponse;
+    /**
+     * Resource not found
+     */
+    404: ErrorResponse;
+    /**
+     * Operation is not waiting for input
+     */
+    409: unknown;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+
+export type ResumeOperationError = ResumeOperationErrors[keyof ResumeOperationErrors];
+
+export type ResumeOperationResponses = {
+    /**
+     * Response Resumeoperation
+     *
+     * Successful Response
+     */
+    202: {
+        [key: string]: unknown;
+    };
+};
+
+export type ResumeOperationResponse = ResumeOperationResponses[keyof ResumeOperationResponses];
+
 export type GetOrgBillingCustomerData = {
     body?: never;
     path: {
@@ -26760,6 +27354,134 @@ export type PreviewEventBlockResponses = {
 
 export type PreviewEventBlockResponse2 = PreviewEventBlockResponses[keyof PreviewEventBlockResponses];
 
+export type PreviewReconcilingItemData = {
+    body: PreviewReconcilingItemRequest;
+    headers?: {
+        /**
+         * Idempotency-Key
+         */
+        'Idempotency-Key'?: string | null;
+    };
+    path: {
+        /**
+         * Graph Id
+         */
+        graph_id: string;
+    };
+    query?: never;
+    url: '/extensions/roboledger/{graph_id}/operations/preview-reconciling-item';
+};
+
+export type PreviewReconcilingItemErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Access denied
+     */
+    403: ErrorResponse;
+    /**
+     * Resource not found
+     */
+    404: ErrorResponse;
+    /**
+     * Idempotency-Key conflict — key reused with different body
+     */
+    409: ErrorResponse;
+    /**
+     * Validation error
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+
+export type PreviewReconcilingItemError = PreviewReconcilingItemErrors[keyof PreviewReconcilingItemErrors];
+
+export type PreviewReconcilingItemResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationEnvelopeReconcilingItemPlan;
+};
+
+export type PreviewReconcilingItemResponse = PreviewReconcilingItemResponses[keyof PreviewReconcilingItemResponses];
+
+export type ResolveReconcilingItemData = {
+    body: ResolveReconcilingItemRequest;
+    headers?: {
+        /**
+         * Idempotency-Key
+         */
+        'Idempotency-Key'?: string | null;
+    };
+    path: {
+        /**
+         * Graph Id
+         */
+        graph_id: string;
+    };
+    query?: never;
+    url: '/extensions/roboledger/{graph_id}/operations/resolve-reconciling-item';
+};
+
+export type ResolveReconcilingItemErrors = {
+    /**
+     * Invalid request
+     */
+    400: ErrorResponse;
+    /**
+     * Authentication required
+     */
+    401: ErrorResponse;
+    /**
+     * Access denied
+     */
+    403: ErrorResponse;
+    /**
+     * Resource not found
+     */
+    404: ErrorResponse;
+    /**
+     * Idempotency-Key conflict — key reused with different body
+     */
+    409: ErrorResponse;
+    /**
+     * Validation error
+     */
+    422: ErrorResponse;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
+};
+
+export type ResolveReconcilingItemError = ResolveReconcilingItemErrors[keyof ResolveReconcilingItemErrors];
+
+export type ResolveReconcilingItemResponses = {
+    /**
+     * Successful Response
+     */
+    200: OperationEnvelopeResolveReconcilingItemResponse;
+};
+
+export type ResolveReconcilingItemResponse2 = ResolveReconcilingItemResponses[keyof ResolveReconcilingItemResponses];
+
 export type UpdateJournalEntryData = {
     body: UpdateJournalEntryRequest;
     headers?: {