@robosystems/client 0.3.19 → 0.3.21

package/artifacts/graphql/generated/graphql.d.ts

@@ -55,6 +55,15 @@ export type Scalars = {
         output: any;
     };
 };
+/**
+ * One CoA account (Element) — the basic chart-of-accounts row.
+ *
+ * ``trait`` carries the FASB classification (asset/liability/equity/
+ * revenue/expense/etc.); ``balance_type`` is the natural side
+ * ('debit' or 'credit'). ``account_type`` is a free-form sub-grouping
+ * (e.g. 'cash', 'inventory') used by some integrations. Hierarchy is
+ * expressed via ``parent_id`` + ``depth``.
+ */
 export type Account = {
     accountType: Maybe<Scalars['String']['output']>;
     balanceType: Scalars['String']['output'];
@@ -72,10 +81,18 @@ export type Account = {
     subClassification: Maybe<Scalars['String']['output']>;
     trait: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Paginated chart-of-accounts listing — flat (use the tree endpoint
+ * for parent/child structure).
+ */
 export type AccountList = {
     accounts: Array<Account>;
     pagination: PaginationInfo;
 };
+/**
+ * All CoA accounts that roll up into a single reporting concept,
+ * with the group total and per-account contributions.
+ */
 export type AccountRollupGroup = {
     accounts: Array<AccountRollupRow>;
     balanceType: Scalars['String']['output'];
@@ -85,6 +102,7 @@ export type AccountRollupGroup = {
     total: Scalars['Float']['output'];
     trait: Scalars['String']['output'];
 };
+/** One CoA account contributing to a reporting concept's rollup. */
 export type AccountRollupRow = {
     accountCode: Maybe<Scalars['String']['output']>;
     accountName: Scalars['String']['output'];
@@ -93,6 +111,11 @@ export type AccountRollupRow = {
     totalCredits: Scalars['Float']['output'];
     totalDebits: Scalars['Float']['output'];
 };
+/**
+ * Mapping rendered as account rollups — every reporting concept the
+ * mapping defines, with the CoA accounts that contribute to it and the
+ * current balance for each. ``total_unmapped`` tracks gaps for UI.
+ */
 export type AccountRollups = {
     groups: Array<AccountRollupGroup>;
     mappingId: Scalars['String']['output'];
@@ -141,6 +164,16 @@ export type Artifact = {
     template: Maybe<Scalars['JSON']['output']>;
     topic: Maybe<Scalars['String']['output']>;
 };
+/**
+ * One edge between two elements within a structure (parent/child
+ * presentation, calculation rollup, mapping, equivalence).
+ *
+ * ``association_type`` discriminates the edge semantics. Mapping edges
+ * are the user-facing path (CoA → reporting concept); presentation /
+ * calculation edges express structure layout and roll-ups.
+ * ``confidence`` is set on AI-suggested mappings (≥0.90 auto-approved,
+ * 0.70-0.89 flagged for review).
+ */
 export type Association = {
     approvedBy: Maybe<Scalars['String']['output']>;
     associationType: Scalars['String']['output'];
@@ -157,10 +190,23 @@ export type Association = {
     toElementQname: Maybe<Scalars['String']['output']>;
     weight: Maybe<Scalars['Float']['output']>;
 };
+/**
+ * A grouping of closing-book items shown as a sidebar section
+ * (e.g. Statements, Account Rollups, Schedules, Period Close).
+ */
 export type ClosingBookCategory = {
     items: Array<ClosingBookItem>;
     label: Scalars['String']['output'];
 };
+/**
+ * One row in the closing book — a navigable artifact for the
+ * period (statement, schedule, rollup, etc.).
+ *
+ * ``item_type`` discriminates: 'statement', 'schedule',
+ * 'account_rollups', 'period_close', 'trial_balance'. Statement items
+ * carry ``report_id`` to fetch the rendered facts; schedule items
+ * carry ``status`` ('complete' | 'draft' | 'pending').
+ */
 export type ClosingBookItem = {
     id: Scalars['String']['output'];
     itemType: Scalars['String']['output'];
@@ -169,10 +215,16 @@ export type ClosingBookItem = {
     status: Maybe<Scalars['String']['output']>;
     structureType: Maybe<Scalars['String']['output']>;
 };
+/**
+ * The closing book navigation tree — categories + items the UI
+ * uses to render the period-close workspace. ``has_data=False`` when
+ * the graph has no posted entries yet.
+ */
 export type ClosingBookStructures = {
     categories: Array<ClosingBookCategory>;
     hasData: Scalars['Boolean']['output'];
 };
+/** A single draft entry with full line item detail for review. */
 export type DraftEntry = {
     /** True if total_debit == total_credit */
     balanced: Scalars['Boolean']['output'];
@@ -193,6 +245,7 @@ export type DraftEntry = {
     /** Entry type (e.g., 'closing', 'adjusting') */
     type: Scalars['String']['output'];
 };
+/** A single line item within a draft entry. */
 export type DraftLineItem = {
     /** Credit amount in cents */
     creditAmount: Scalars['Int']['output'];
@@ -204,6 +257,7 @@ export type DraftLineItem = {
     elementName: Scalars['String']['output'];
     lineItemId: Scalars['String']['output'];
 };
+/** Element with taxonomy context — extends AccountResponse. */
 export type Element = {
     balanceType: Scalars['String']['output'];
     code: Maybe<Scalars['String']['output']>;
@@ -225,13 +279,22 @@ export type Element = {
     taxonomyId: Maybe<Scalars['String']['output']>;
     trait: Maybe<Scalars['String']['output']>;
 };
+/** Paginated element listing with taxonomy context. */
 export type ElementList = {
     elements: Array<Element>;
     pagination: PaginationInfo;
 };
+/**
+ * Lightweight entity projection for embedding in portfolio-block /
+ * position envelopes. Carries identity-only fields; full entity data
+ * lives behind the Master Data entity APIs.
+ */
 export type EntityLite = {
+    /** Entity ID (`ent_*` ULID). */
     id: Scalars['ID']['output'];
+    /** Display name of the entity. */
     name: Scalars['String']['output'];
+    /** Tenant graph this entity is anchored to, when known. `null` for entities not yet linked to a graph. */
     sourceGraphId: Maybe<Scalars['String']['output']>;
 };
 export type EventBlock = {
@@ -260,15 +323,29 @@ export type EventBlock = {
     source: Scalars['String']['output'];
     status: Scalars['String']['output'];
 };
+/**
+ * A single fact row inside a rendered statement.
+ *
+ * One row per concept, with one value per period column. Subtotals and
+ * hierarchy depth come from the structure being projected.
+ */
 export type FactRow = {
+    /** Indentation depth in the structure hierarchy (0 = root). */
     depth: Scalars['Int']['output'];
+    /** Internal element identifier. */
     elementId: Scalars['String']['output'];
+    /** Human-readable concept label. */
     elementName: Scalars['String']['output'];
+    /** QName of the reporting concept (e.g. 'us-gaap:Revenues'). */
     elementQname: Scalars['String']['output'];
+    /** True when the row should render as a subtotal line. */
     isSubtotal: Scalars['Boolean']['output'];
+    /** Concept trait flag from the structure (e.g. 'total', 'subtotal', 'header'). Drives presentation. */
     trait: Maybe<Scalars['String']['output']>;
+    /** One value per period column, in the same order as `periods`. Null when the concept had no facts in that window. */
     values: Array<Maybe<Scalars['Float']['output']>>;
 };
+/** Current fiscal calendar state for a graph. */
 export type FiscalCalendar = {
     /** Structured blocker codes when closeable_now is False: 'sequence_violation', 'period_incomplete', 'sync_stale', 'calendar_not_initialized', 'period_already_closed' */
     blockers: Array<Scalars['String']['output']>;
@@ -291,6 +368,13 @@ export type FiscalCalendar = {
     /** Fiscal period rows for this graph */
     periods: Array<FiscalPeriodSummary>;
 };
+/**
+ * One fiscal period row — header view used in calendar listings.
+ *
+ * Status lifecycle: ``open`` → ``closing`` → ``closed``. ``closing``
+ * is the transient state during a close run; ``closed_at`` stamps when
+ * the lock landed.
+ */
 export type FiscalPeriodSummary = {
     closedAt: Maybe<Scalars['DateTime']['output']>;
     endDate: Scalars['Date']['output'];
@@ -300,27 +384,50 @@ export type FiscalPeriodSummary = {
     /** 'open' | 'closing' | 'closed' */
     status: Scalars['String']['output'];
 };
+/**
+ * All securities held in a single entity, rolled up across the
+ * caller's portfolios.
+ */
 export type Holding = {
+    /** Issuing entity ID. */
     entityId: Scalars['String']['output'];
+    /** Display name of the entity. */
     entityName: Scalars['String']['output'];
+    /** Number of distinct active positions backing these holdings. */
     positionCount: Scalars['Int']['output'];
+    /** One row per security held in this entity. */
     securities: Array<HoldingSecuritySummary>;
+    /** Pre-association tenant graph, when set on the securities. */
     sourceGraphId: Maybe<Scalars['String']['output']>;
+    /** Sum of cost basis across all securities, in dollars. */
     totalCostBasisDollars: Scalars['Float']['output'];
+    /** Sum of current value across all securities, in dollars. `null` if any security lacks a mark. */
     totalCurrentValueDollars: Maybe<Scalars['Float']['output']>;
 };
+/** One security held by an entity, rolled up across portfolios. */
 export type HoldingSecuritySummary = {
+    /** Aggregate cost basis in dollars, summed across all positions. */
     costBasisDollars: Scalars['Float']['output'];
+    /** Aggregate current value in dollars, or `null` if any underlying position lacks a mark. */
     currentValueDollars: Maybe<Scalars['Float']['output']>;
+    /** Total quantity held in `quantity_type` units. */
     quantity: Scalars['Float']['output'];
+    /** Unit basis (`shares`, `units`, `principal`). */
     quantityType: Scalars['String']['output'];
+    /** Security ID. */
     securityId: Scalars['String']['output'];
+    /** Display name of the security. */
     securityName: Scalars['String']['output'];
+    /** Instrument family (e.g. `common_stock`, `warrant`). */
     securityType: Scalars['String']['output'];
 };
+/** Aggregated holdings across all of the caller's portfolios. */
 export type HoldingsList = {
+    /** One row per issuing entity. */
     holdings: Array<Holding>;
+    /** Count of entities represented. */
     totalEntities: Scalars['Int']['output'];
+    /** Total active positions backing these holdings. */
     totalPositions: Scalars['Int']['output'];
 };
 export type InformationBlock = {
@@ -342,6 +449,19 @@ export type InformationBlock = {
     verificationResults: Array<InformationBlockVerificationResult>;
     view: InformationBlockViewProjections;
 };
+/**
+ * Classification projection — one row per `association_classifications`
+ * junction entry.
+ *
+ * Association-side only: concept_arrangement, member_arrangement,
+ * named_disclosure. Element-side FASB metamodel traits (asset, current,
+ * operating, …) live in `TraitLite` via `element_traits`.
+ *
+ * Carries enough for the envelope caller to render / filter by category +
+ * identifier without a follow-up lookup. The full `public.classifications`
+ * vocabulary catalog (name / description / metadata) is available via the
+ * library GraphQL surface when callers need the details.
+ */
 export type InformationBlockClassification = {
     /** One of the 3 association-level categories in the `public.classifications` CHECK constraint: 'concept_arrangement', 'member_arrangement', or 'named_disclosure'. */
     category: Scalars['String']['output'];
@@ -356,6 +476,12 @@ export type InformationBlockClassification = {
     /** Provenance — 'arcrole_analysis', 'disclosure_mechanics', 'us-gaap-metamodel', adapter name, etc. */
     source: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Connection (= Association) projection.
+ *
+ * Renamed at the API boundary to match Charlie's ontology vocabulary.
+ * The underlying storage table is still ``associations``.
+ */
 export type InformationBlockConnection = {
     arcrole: Maybe<Scalars['String']['output']>;
     /** presentation | calculation | mapping | equivalence | general-special | essence-alias */
@@ -368,6 +494,14 @@ export type InformationBlockConnection = {
     toElementId: Scalars['String']['output'];
     weight: Maybe<Scalars['Float']['output']>;
 };
+/**
+ * Element projection for bundling inside an Information Block envelope.
+ *
+ * Narrower than :class:`LibraryElementResponse` — excludes the heavy fields
+ * (labels, references, classifications) that library browsing needs but
+ * block consumers don't. Agents + frontends ask for those on demand via
+ * the full library GraphQL fields when they need them.
+ */
 export type InformationBlockElement = {
     balanceType: Maybe<Scalars['String']['output']>;
     code: Maybe<Scalars['String']['output']>;
@@ -380,6 +514,7 @@ export type InformationBlockElement = {
     periodType: Maybe<Scalars['String']['output']>;
     qname: Maybe<Scalars['String']['output']>;
 };
+/** Fact projection — just the values the envelope caller cares about. */
 export type InformationBlockFact = {
     elementId: Scalars['String']['output'];
     /** historical | in_scope */
@@ -392,6 +527,14 @@ export type InformationBlockFact = {
     unit: Scalars['String']['output'];
     value: Scalars['Float']['output'];
 };
+/**
+ * FactSet projection — period-specific instantiation of the Structure.
+ *
+ * The envelope carries one ``FactSetLite`` per block when a FactSet row
+ * exists for the requested period; legacy writes that pre-date FactSet
+ * stamping leave ``fact_set`` null until the expand pass starts
+ * populating those rows.
+ */
 export type InformationBlockFactSet = {
     entityId: Scalars['String']['output'];
     /** 'report' | 'schedule' | 'custom'. Enum closure enforced by the ``public.fact_sets`` CHECK constraint. */
@@ -403,17 +546,36 @@ export type InformationBlockFactSet = {
     reportId: Maybe<Scalars['String']['output']>;
     structureId: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Pre-computed rendering projection of an Information Block.
+ *
+ * Computed server-side at envelope-build time for blocks where rendering
+ * is deterministic (the statement family today; future block types add
+ * their own rendering builders). The frontend's ``BlockView``
+ * ``Rendering`` projection consumes this directly — no client-side
+ * rollup, depth computation, or calculation walk needed.
+ */
 export type InformationBlockRendering = {
     periods: Array<InformationBlockRenderingPeriod>;
     rows: Array<InformationBlockRenderingRow>;
     unmappedCount: Scalars['Int']['output'];
     validation: Maybe<InformationBlockValidation>;
 };
+/** One period column in a rendered statement. */
 export type InformationBlockRenderingPeriod = {
     end: Scalars['Date']['output'];
     label: Maybe<Scalars['String']['output']>;
     start: Scalars['Date']['output'];
 };
+/**
+ * One row of a server-side rendered statement.
+ *
+ * Mirrors :class:`FactRow` from the legacy
+ * :mod:`robosystems.operations.roboledger.reports.fact_grid` but lives at
+ * the API boundary so envelope consumers don't depend on the
+ * fact-grid module. ``values`` is one entry per period column in
+ * :class:`RenderingLite.periods`.
+ */
 export type InformationBlockRenderingRow = {
     balanceType: Maybe<Scalars['String']['output']>;
     /** FASB elementsOfFinancialStatements trait identifier — 'asset', 'liability', 'equity', 'revenue', 'expense'. Surfaced so the viewer can color-code or group rows without a follow-up trait lookup. */
@@ -425,6 +587,15 @@ export type InformationBlockRenderingRow = {
     isSubtotal: Scalars['Boolean']['output'];
     values: Array<Maybe<Scalars['Float']['output']>>;
 };
+/**
+ * Rule projection for the Information Block envelope.
+ *
+ * One row per ``public.rules`` entry scoped to this block. The rule
+ * engine consumes ``rule_expression`` + ``rule_variables`` to evaluate
+ * against the in-scope fact set; the envelope surfaces the rules so
+ * the UI can render them as a checklist alongside any persisted
+ * verification results.
+ */
 export type InformationBlockRule = {
     id: Scalars['String']['output'];
     /** One of 8 cm:VerificationRule subclasses — AutomatedAccountingAndReportingChecks, FundamentalAccountingConceptRelation, PeerConsistencyRule, PriorPeriodConsistencyRule, ReportLevelModelStructureRule, ReportingSystemSpecificRule, ToDoManualTask, XBRLTechnicalSyntaxRule. */
@@ -440,24 +611,42 @@ export type InformationBlockRule = {
     ruleTarget: Maybe<InformationBlockRuleTarget>;
     ruleVariables: Array<InformationBlockRuleVariable>;
 };
+/** Polymorphic rule target — points at the atom the rule is scoped to. */
 export type InformationBlockRuleTarget = {
     /** Which atom type the rule targets — 'structure' | 'element' | 'association' | 'taxonomy'. Enum closure enforced by the ``public.rules`` CHECK constraint. */
     targetKind: Scalars['String']['output'];
     /** UUID of the target atom — structure_id, element_id, association_id, or taxonomy_id depending on ``target_kind``. */
     targetRefId: Scalars['String']['output'];
 };
+/** `$Variable` → concept qname binding for a rule expression. */
 export type InformationBlockRuleVariable = {
     /** Local name in the rule expression, e.g. 'Assets'. */
     variableName: Scalars['String']['output'];
     /** Concept qname the variable resolves to, e.g. 'fac:Assets'. */
     variableQname: Scalars['String']['output'];
 };
+/**
+ * Outcome of guard-rail validation on a rendered statement.
+ *
+ * Distinct from :class:`VerificationResultLite` (which surfaces the
+ * rule-engine outcomes from ``public.verification_results``). This lite
+ * type carries the synchronous guard-rail checks computed at
+ * envelope-build time — accounting equation, totals foot, etc.
+ */
 export type InformationBlockValidation = {
     checks: Array<Scalars['String']['output']>;
     failures: Array<Scalars['String']['output']>;
     passed: Scalars['Boolean']['output'];
     warnings: Array<Scalars['String']['output']>;
 };
+/**
+ * Persisted outcome of one Rule evaluation.
+ *
+ * One row per ``public.verification_results`` entry the rule engine
+ * writes. The envelope surfaces them so the block viewer's
+ * "Verification Results" tab and MCP ``list-verification-failures``
+ * tool can render + aggregate without a second round-trip.
+ */
 export type InformationBlockVerificationResult = {
     evaluatedAt: Maybe<Scalars['DateTime']['output']>;
     factSetId: Maybe<Scalars['String']['output']>;
@@ -470,49 +659,106 @@ export type InformationBlockVerificationResult = {
     status: Scalars['String']['output'];
     structureId: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Charlie's six ``type-of View`` arms, surfaced at the envelope boundary.
+ *
+ * Each projection is computed server-side at envelope-build time when
+ * its source data is available. The frontend's ``BlockView`` dispatcher
+ * routes to the projection component matching the user's selected view
+ * mode; missing projections (those still in backlog) render as empty
+ * states without breaking the dispatcher.
+ *
+ * Today: ``rendering`` is computed for the statement family.
+ * Other arms (``fact_table``, ``model_structure``, ``verification_results``,
+ * ``report_elements``, ``business_rules``) come online as their backend
+ * support lands; ``fact_table`` is trivially derivable from
+ * ``InformationBlockEnvelope.facts`` and may stay as a frontend-only
+ * projection.
+ */
 export type InformationBlockViewProjections = {
     rendering: Maybe<InformationBlockRendering>;
 };
+/** The block's intrinsic shape — concept + member arrangement patterns. */
 export type InformationModel = {
     /** roll_up | roll_forward | variance | adjustment | set | arithmetic | textblock. Null for block types where the concept arrangement is implicit in their mechanics. */
     conceptArrangement: Maybe<Scalars['String']['output']>;
     /** aggregation | nonaggregation, or null if non-hypercube. */
     memberArrangement: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Entity details from the extensions OLTP database.
+ *
+ * Returned by entity reads and `update-entity`. Identifiers
+ * (CIK / ticker / SIC / LEI / tax_id) are present when sourced from
+ * SEC or registry data; many are null for private companies. The
+ * address fields are flattened (no nested object) to make them easy
+ * to project into reporting forms.
+ */
 export type LedgerEntity = {
     addressCity: Maybe<Scalars['String']['output']>;
     addressCountry: Maybe<Scalars['String']['output']>;
     addressLine1: Maybe<Scalars['String']['output']>;
     addressPostalCode: Maybe<Scalars['String']['output']>;
     addressState: Maybe<Scalars['String']['output']>;
+    /** Filer category (e.g. 'Large Accelerated Filer'). */
     category: Maybe<Scalars['String']['output']>;
+    /** SEC CIK (Central Index Key). */
     cik: Maybe<Scalars['String']['output']>;
+    /** Source connection that ingested this row. */
     connectionId: Maybe<Scalars['String']['output']>;
     createdAt: Maybe<Scalars['String']['output']>;
+    /** Legal form (e.g. 'corporation', 'llc', 'lp'). */
     entityType: Maybe<Scalars['String']['output']>;
+    /** Listing exchange (e.g. 'NASDAQ', 'NYSE'). */
     exchange: Maybe<Scalars['String']['output']>;
+    /** Fiscal year-end as MM-DD (e.g. '12-31', '06-30'). */
     fiscalYearEnd: Maybe<Scalars['String']['output']>;
+    /** Entity identifier (ULID). */
     id: Scalars['String']['output'];
+    /** Free-form industry label. */
     industry: Maybe<Scalars['String']['output']>;
+    /** True for top-level entities; False for subsidiaries. */
     isParent: Scalars['Boolean']['output'];
+    /** Full registered legal name (when different from `name`). */
     legalName: Maybe<Scalars['String']['output']>;
+    /** Legal Entity Identifier (ISO 17442). */
     lei: Maybe<Scalars['String']['output']>;
+    /** Display name shown in UI. */
     name: Scalars['String']['output'];
+    /** Parent entity ID for subsidiaries; null for top-level. */
     parentEntityId: Maybe<Scalars['String']['output']>;
     phone: Maybe<Scalars['String']['output']>;
+    /** SIC industry code. */
     sic: Maybe<Scalars['String']['output']>;
+    /** SIC code description. */
     sicDescription: Maybe<Scalars['String']['output']>;
+    /** Provenance: 'native' | 'sec' | 'quickbooks' | 'xero' | 'plaid'. */
     source: Scalars['String']['output'];
+    /** Origin graph for received entities (cross-graph linking, e.g. RoboInvestor portfolio holdings). */
     sourceGraphId: Maybe<Scalars['String']['output']>;
+    /** Source-system primary key for sync reconciliation. */
     sourceId: Maybe<Scalars['String']['output']>;
+    /** US state or country of incorporation. */
     stateOfIncorporation: Maybe<Scalars['String']['output']>;
+    /** Operational status: 'active' | 'inactive' | 'dissolved'. */
     status: Scalars['String']['output'];
+    /** Tax ID (EIN / SSN). */
     taxId: Maybe<Scalars['String']['output']>;
+    /** Stock ticker symbol. */
     ticker: Maybe<Scalars['String']['output']>;
     updatedAt: Maybe<Scalars['String']['output']>;
+    /** Canonical URL / external identifier. */
     uri: Maybe<Scalars['String']['output']>;
     website: Maybe<Scalars['String']['output']>;
 };
+/**
+ * A journal entry — accounting interpretation of a transaction.
+ *
+ * Each transaction has 1+ entries; each entry has 2+ line items that
+ * must balance. ``status`` is the draft/posted/reversed lifecycle;
+ * ``type`` is the entry classification ('standard' | 'adjusting' |
+ * 'closing' | 'reversing').
+ */
 export type LedgerEntry = {
     id: Scalars['String']['output'];
     lineItems: Array<LedgerLineItem>;
@@ -523,6 +769,10 @@ export type LedgerEntry = {
     status: Scalars['String']['output'];
     type: Scalars['String']['output'];
 };
+/**
+ * One debit/credit line within a journal entry. Always exactly one
+ * side has a non-zero amount.
+ */
 export type LedgerLineItem = {
     accountCode: Maybe<Scalars['String']['output']>;
     accountId: Scalars['String']['output'];
@@ -533,6 +783,15 @@ export type LedgerLineItem = {
     id: Scalars['String']['output'];
     lineOrder: Scalars['Int']['output'];
 };
+/**
+ * High-level rollup of a graph's ledger state — counts plus the
+ * date-range bookends and integration sync timestamp.
+ *
+ * Used by dashboards and the onboarding wizard to answer "is this
+ * graph populated yet?" without walking every transaction. ``connection_count``
+ * reflects active integrations (QuickBooks / Plaid / etc.); a non-null
+ * ``last_sync_at`` means at least one connection has run.
+ */
 export type LedgerSummary = {
     accountCount: Scalars['Int']['output'];
     connectionCount: Scalars['Int']['output'];
@@ -544,6 +803,10 @@ export type LedgerSummary = {
     lineItemCount: Scalars['Int']['output'];
     transactionCount: Scalars['Int']['output'];
 };
+/**
+ * Full transaction detail — header + every journal entry + every
+ * line item underneath. Used by the transaction detail page.
+ */
 export type LedgerTransactionDetail = {
     amount: Scalars['Float']['output'];
     category: Maybe<Scalars['String']['output']>;
@@ -562,10 +825,19 @@ export type LedgerTransactionDetail = {
     status: Scalars['String']['output'];
     type: Scalars['String']['output'];
 };
+/** Paginated transaction listing — header view. */
 export type LedgerTransactionList = {
     pagination: PaginationInfo;
     transactions: Array<LedgerTransactionSummary>;
 };
+/**
+ * Transaction header — list/grid view without entries.
+ *
+ * Transaction is the business-event level (what happened in the real
+ * world). Entries (journal entries) live one level down and are loaded
+ * in the detail view. ``source`` distinguishes integration-imported
+ * rows (quickbooks / xero / plaid) from native-created ones.
+ */
 export type LedgerTransactionSummary = {
     amount: Scalars['Float']['output'];
     category: Maybe<Scalars['String']['output']>;
@@ -581,6 +853,7 @@ export type LedgerTransactionSummary = {
     status: Scalars['String']['output'];
     type: Scalars['String']['output'];
 };
+/** An arc between two library elements (parent-child, equivalence, etc). */
 export type LibraryAssociation = {
     arcrole: Maybe<Scalars['String']['output']>;
     /** presentation | calculation | mapping | equivalence | general-special | essence-alias */
@@ -597,6 +870,7 @@ export type LibraryAssociation = {
     toElementQname: Maybe<Scalars['String']['output']>;
     weight: Maybe<Scalars['Float']['output']>;
 };
+/** A library element (concept, abstract, axis, member, or hypercube). */
 export type LibraryElement = {
     /** debit | credit */
     balanceType: Scalars['String']['output'];
@@ -620,6 +894,18 @@ export type LibraryElement = {
     /** FASB elementsOfFinancialStatements axis: asset | contraAsset | liability | contraLiability | equity | contraEquity | temporaryEquity | revenue | expense | expenseReversal | gain | loss | comprehensiveIncome | investmentByOwners | distributionToOwners | metric (derived subtotals, not SFAC 6 primary elements). Null for structural rows. */
     trait: Maybe<Scalars['String']['output']>;
 };
+/**
+ * A mapping arc involving a specific element.
+ *
+ * Flat row view: one arc, oriented from the perspective of the element
+ * being inspected. `peer` is the other end; `direction` says whether
+ * this element is the source ('outgoing') or the target ('incoming').
+ *
+ * Scoped to arcs whose structure belongs to a `taxonomy_type='mapping'`
+ * taxonomy — the cross-taxonomy bridges (equivalence, general-special,
+ * type-subtype). Hierarchical arcs inside a single reporting taxonomy
+ * are out of scope.
+ */
 export type LibraryElementArc = {
     arcrole: Maybe<Scalars['String']['output']>;
     associationType: Scalars['String']['output'];
@@ -633,6 +919,13 @@ export type LibraryElementArc = {
     taxonomyName: Maybe<Scalars['String']['output']>;
     taxonomyStandard: Maybe<Scalars['String']['output']>;
 };
+/**
+ * One FASB metamodel trait assigned to a library element.
+ *
+ * A single element can carry multiple traits across multiple categories
+ * (e.g. elementsOfFinancialStatements=expense AND
+ * operatingNonoperating=operating AND liquidity=current).
+ */
 export type LibraryElementClassification = {
     /** Trait axis (e.g. elementsOfFinancialStatements) */
     category: Scalars['String']['output'];
@@ -647,10 +940,17 @@ export type LibraryElementTreeNode = {
     children: Array<LibraryElementTreeNode>;
     element: LibraryElement;
 };
+/**
+ * An element and its equivalence peers.
+ *
+ * Answers "what other concepts mean the same thing as this one" — the
+ * FAC→us-gaap collapse pattern rendered as an API shape.
+ */
 export type LibraryEquivalence = {
     element: LibraryElement;
     equivalents: Array<LibraryElement>;
 };
+/** A label on a library element. */
 export type LibraryLabel = {
     /** Language code */
     language: Scalars['String']['output'];
@@ -659,6 +959,7 @@ export type LibraryLabel = {
     /** Label text */
     text: Scalars['String']['output'];
 };
+/** A cross-reference on a library element (FASB ASC, SEC, etc). */
 export type LibraryReference = {
     /** Full citation text */
     citation: Scalars['String']['output'];
@@ -667,6 +968,7 @@ export type LibraryReference = {
     /** Dereferenceable URL if available */
     uri: Maybe<Scalars['String']['output']>;
 };
+/** A named structure (extended link role) within a library taxonomy. */
 export type LibraryStructure = {
     id: Scalars['String']['output'];
     isActive: Scalars['Boolean']['output'];
@@ -677,6 +979,7 @@ export type LibraryStructure = {
     structureType: Scalars['String']['output'];
     taxonomyId: Scalars['String']['output'];
 };
+/** A library taxonomy (fac, us-gaap, rs-gaap, …). */
 export type LibraryTaxonomy = {
     description: Maybe<Scalars['String']['output']>;
     /** Total elements in this taxonomy (computed on demand) */
@@ -693,10 +996,12 @@ export type LibraryTaxonomy = {
     taxonomyType: Scalars['String']['output'];
     version: Maybe<Scalars['String']['output']>;
 };
+/** Trial balance rolled up to reporting concepts via mapping associations. */
 export type MappedTrialBalance = {
     mappingId: Scalars['String']['output'];
     rows: Array<MappedTrialBalanceRow>;
 };
+/** One reporting-concept row in the mapped trial balance. */
 export type MappedTrialBalanceRow = {
     balanceType: Maybe<Scalars['String']['output']>;
     netBalance: Scalars['Float']['output'];
@@ -707,6 +1012,7 @@ export type MappedTrialBalanceRow = {
     totalDebits: Scalars['Float']['output'];
     trait: Maybe<Scalars['String']['output']>;
 };
+/** Coverage stats for a mapping. */
 export type MappingCoverage = {
     coveragePercent: Scalars['Float']['output'];
     highConfidence: Scalars['Int']['output'];
@@ -717,6 +1023,7 @@ export type MappingCoverage = {
     totalCoaElements: Scalars['Int']['output'];
     unmappedCount: Scalars['Int']['output'];
 };
+/** A mapping structure with all its associations. */
 export type MappingDetail = {
     associations: Array<Association>;
     id: Scalars['String']['output'];
@@ -725,6 +1032,7 @@ export type MappingDetail = {
     taxonomyId: Scalars['String']['output'];
     totalAssociations: Scalars['Int']['output'];
 };
+/** Pagination information for list responses. */
 export type PaginationInfo = {
     /** Whether more items are available */
     hasMore: Scalars['Boolean']['output'];
@@ -735,6 +1043,13 @@ export type PaginationInfo = {
     /** Total number of items available */
     total: Scalars['Int']['output'];
 };
+/**
+ * One schedule's contribution to a period close — drafted closing
+ * entry plus its reversal (when ``auto_reverse=True``).
+ *
+ * ``status`` is the closing entry's draft/posted lifecycle. The
+ * reversal mirrors the same shape with ``reversal_*`` fields.
+ */
 export type PeriodCloseItem = {
     amount: Scalars['Float']['output'];
     entryId: Maybe<Scalars['String']['output']>;
@@ -744,6 +1059,14 @@ export type PeriodCloseItem = {
     structureId: Scalars['String']['output'];
     structureName: Scalars['String']['output'];
 };
+/**
+ * Period-close dashboard view — every schedule in scope for the
+ * period plus drafted/posted entry totals.
+ *
+ * Use to drive the close-period UI: schedules with ``status='draft'``
+ * are pending close; ``period_status`` reflects the calendar's lock
+ * state for the period.
+ */
 export type PeriodCloseStatus = {
     fiscalPeriodEnd: Scalars['Date']['output'];
     fiscalPeriodStart: Scalars['Date']['output'];
@@ -752,6 +1075,7 @@ export type PeriodCloseStatus = {
     totalDraft: Scalars['Int']['output'];
     totalPosted: Scalars['Int']['output'];
 };
+/** All draft entries for a fiscal period, ready for review before close. */
 export type PeriodDrafts = {
     /** True if every draft entry has debit == credit */
     allBalanced: Scalars['Boolean']['output'];
@@ -766,108 +1090,234 @@ export type PeriodDrafts = {
     /** Sum across all drafts, in cents */
     totalDebit: Scalars['Int']['output'];
 };
+/**
+ * A single reporting period column.
+ *
+ * Reports render facts in N period columns side-by-side. Each
+ * ``PeriodSpec`` is one column — its ``start``/``end`` define the
+ * window the report's facts roll up into; ``label`` is what the renderer
+ * prints in the column header. For year-over-year statements, supply two
+ * PeriodSpecs (current + comparative); for YTD by quarter, supply four.
+ */
 export type PeriodSpec = {
+    /** Period end date (inclusive). Window the column rolls up. */
     end: Scalars['Date']['output'];
+    /** Column header label (e.g. 'FY2025 Q3', '2024', 'YTD'). */
     label: Scalars['String']['output'];
+    /** Period start date (inclusive). Window the column rolls up. */
     start: Scalars['Date']['output'];
 };
+/**
+ * Read projection for a single portfolio — core fields only.
+ *
+ * Position-level holdings live on the dedicated portfolio-block envelope
+ * (`PortfolioBlockEnvelope`) returned by molecular operations.
+ */
 export type Portfolio = {
+    /** ISO 4217 currency code used for portfolio-level aggregates. */
     baseCurrency: Scalars['String']['output'];
+    /** Row creation timestamp (UTC). */
     createdAt: Scalars['DateTime']['output'];
+    /** Free-text description. */
     description: Maybe<Scalars['String']['output']>;
+    /** Portfolio ID (`port_*` ULID). */
     id: Scalars['String']['output'];
+    /** Date the portfolio was established (YYYY-MM-DD). */
     inceptionDate: Maybe<Scalars['Date']['output']>;
+    /** Display name. */
     name: Scalars['String']['output'];
+    /** Free-text strategy classification (e.g. `value`, `growth`, `income`). Open vocabulary. */
     strategy: Maybe<Scalars['String']['output']>;
+    /** Last-modified timestamp (UTC). */
     updatedAt: Scalars['DateTime']['output'];
 };
+/**
+ * Molecular response shape for portfolio-block operations.
+ *
+ * Bundles the portfolio core, its embedded positions, and pre-computed
+ * totals into a single payload — the contract for `create-portfolio-block`,
+ * `update-portfolio-block`, and the read-side `get-portfolio-block`.
+ * Cents-precision values aren't surfaced here; use `PositionResponse`
+ * / `PortfolioResponse` for those.
+ */
 export type PortfolioBlock = {
+    /** Count of positions with `status='active'`. */
     activePositionCount: Scalars['Int']['output'];
+    /** ISO 4217 currency code for portfolio aggregates. */
     baseCurrency: Scalars['String']['output'];
+    /** Row creation timestamp (UTC). */
     createdAt: Scalars['DateTime']['output'];
+    /** Free-text description. */
     description: Maybe<Scalars['String']['output']>;
+    /** Portfolio ID (`port_*` ULID). */
     id: Scalars['ID']['output'];
+    /** Date the portfolio was established. */
     inceptionDate: Maybe<Scalars['Date']['output']>;
+    /** Display name. */
     name: Scalars['String']['output'];
+    /** Embedded owning entity, when set. `null` for unattributed portfolios. */
     owner: Maybe<EntityLite>;
+    /** All positions in this portfolio, including disposed ones (filter by `status` for active-only display). */
     positions: Array<PositionBlock>;
+    /** Free-text strategy classification. */
     strategy: Maybe<Scalars['String']['output']>;
+    /** Sum of `cost_basis_dollars` across every position. */
     totalCostBasisDollars: Scalars['Float']['output'];
+    /** Sum of `current_value_dollars` across every position. `null` when any active position lacks a mark. */
     totalCurrentValueDollars: Maybe<Scalars['Float']['output']>;
+    /** Last-modified timestamp (UTC). */
     updatedAt: Scalars['DateTime']['output'];
 };
+/** Paginated list of portfolios. */
 export type PortfolioList = {
+    /** Pagination cursor and totals. */
     pagination: PaginationInfo;
+    /** Portfolios on this page. */
     portfolios: Array<Portfolio>;
 };
+/**
+ * Read projection for a single position.
+ *
+ * Pairs cents-precision fields (`cost_basis`, `current_value`) with
+ * pre-computed dollar floats (`*_dollars`) to spare clients the
+ * conversion. The cents fields are authoritative.
+ */
 export type Position = {
+    /** Date the position was acquired (YYYY-MM-DD). */
     acquisitionDate: Maybe<Scalars['Date']['output']>;
+    /** Cost basis in **cents** of `currency`. Authoritative. */
     costBasis: Scalars['Int']['output'];
+    /** Cost basis pre-converted to dollars (`cost_basis / 100`). Convenience for display; `cost_basis` is the source of truth. */
     costBasisDollars: Scalars['Float']['output'];
+    /** Row creation timestamp (UTC). */
     createdAt: Scalars['DateTime']['output'];
+    /** ISO 4217 currency code for `cost_basis` and `current_value`. */
     currency: Scalars['String']['output'];
+    /** Latest mark-to-market value in **cents**, or `null` if unmarked. */
     currentValue: Maybe<Scalars['Int']['output']>;
+    /** Current value in dollars (`current_value / 100`). `null` when `current_value` is null. */
     currentValueDollars: Maybe<Scalars['Float']['output']>;
+    /** Date the position was disposed, if `status='disposed'`. `null` for active positions. */
     dispositionDate: Maybe<Scalars['Date']['output']>;
+    /** Cached display name of the security's issuing entity. */
     entityName: Maybe<Scalars['String']['output']>;
+    /** Position ID (`pos_*` ULID). */
     id: Scalars['String']['output'];
+    /** Free-text notes attached to the position. */
     notes: Maybe<Scalars['String']['output']>;
+    /** Owning portfolio ID. */
     portfolioId: Scalars['String']['output'];
+    /** Quantity held in units defined by `quantity_type`. */
     quantity: Scalars['Float']['output'];
+    /** Unit basis (`shares`, `units`, `principal`). */
     quantityType: Scalars['String']['output'];
+    /** Held security ID. */
     securityId: Scalars['String']['output'];
+    /** Cached display name of the held security, denormalized for list rendering. May lag the security row's current name briefly. */
     securityName: Maybe<Scalars['String']['output']>;
+    /** Lifecycle state. One of: `active` (currently held), `disposed` (soft-deleted via `update-portfolio-block` dispose), `archived` (historical record only). */
     status: Scalars['String']['output'];
+    /** Last-modified timestamp (UTC). */
     updatedAt: Scalars['DateTime']['output'];
+    /** Date `current_value` was sourced (YYYY-MM-DD). */
     valuationDate: Maybe<Scalars['Date']['output']>;
+    /** Free-text source attribution for the current valuation. */
     valuationSource: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Position projection embedded inside a `PortfolioBlockEnvelope`.
+ *
+ * Pre-converts cents fields to dollars (`cost_basis_dollars`,
+ * `current_value_dollars`) for display; the cents-precision fields
+ * live on the standalone `PositionResponse`. Embeds a `SecurityLite`
+ * so callers can render the security name without a follow-up fetch.
+ */
 export type PositionBlock = {
+    /** Date the position was acquired. */
     acquisitionDate: Maybe<Scalars['Date']['output']>;
+    /** Cost basis in dollars (pre-converted from cents). */
     costBasisDollars: Scalars['Float']['output'];
+    /** Latest mark-to-market value in dollars. `null` when the position has not been marked. */
     currentValueDollars: Maybe<Scalars['Float']['output']>;
+    /** Position ID (`pos_*` ULID). */
     id: Scalars['ID']['output'];
+    /** Free-text notes attached to the position. */
     notes: Maybe<Scalars['String']['output']>;
+    /** Quantity held in `quantity_type` units. */
     quantity: Scalars['Float']['output'];
+    /** Unit basis (`shares`, `units`, `principal`). */
     quantityType: Scalars['String']['output'];
+    /** Embedded security details — name, type, issuer. */
     security: SecurityLite;
+    /** Lifecycle state (`active`, `disposed`, `archived`). See `PositionResponse.status` for the full vocabulary. */
     status: Scalars['String']['output'];
+    /** Date the current value was sourced. */
     valuationDate: Maybe<Scalars['Date']['output']>;
+    /** Free-text source attribution for the valuation. */
     valuationSource: Maybe<Scalars['String']['output']>;
 };
+/** Paginated list of positions. */
 export type PositionList = {
+    /** Pagination cursor and totals. */
     pagination: PaginationInfo;
+    /** Positions on this page. */
     positions: Array<Position>;
 };
+/** Publish list summary — header metadata, no members. */
 export type PublishList = {
+    /** When the list was created. */
     createdAt: Scalars['DateTime']['output'];
+    /** User ID that created the list. */
     createdBy: Scalars['String']['output'];
+    /** Free-form description. */
     description: Maybe<Scalars['String']['output']>;
+    /** List identifier (ULID). */
     id: Scalars['String']['output'];
+    /** Number of recipient graphs currently on the list. */
     memberCount: Scalars['Int']['output'];
+    /** Human-readable list name. */
     name: Scalars['String']['output'];
+    /** Last metadata update (name/description). */
     updatedAt: Scalars['DateTime']['output'];
 };
+/** Full detail including members. */
 export type PublishListDetail = {
+    /** When the list was created. */
     createdAt: Scalars['DateTime']['output'];
+    /** User ID that created the list. */
     createdBy: Scalars['String']['output'];
+    /** Free-form description. */
     description: Maybe<Scalars['String']['output']>;
+    /** List identifier (ULID). */
     id: Scalars['String']['output'];
+    /** Number of recipient graphs currently on the list. */
     memberCount: Scalars['Int']['output'];
+    /** All recipient graphs on the list. */
     members: Array<PublishListMember>;
+    /** Human-readable list name. */
     name: Scalars['String']['output'];
+    /** Last metadata update (name/description). */
     updatedAt: Scalars['DateTime']['output'];
 };
+/** Paginated list of publish lists owned by the current graph. */
 export type PublishListList = {
     pagination: PaginationInfo;
+    /** Publish list summaries, newest first. */
     publishLists: Array<PublishList>;
 };
+/** One recipient graph in a publish list. */
 export type PublishListMember = {
+    /** When the member was added. */
     addedAt: Scalars['DateTime']['output'];
+    /** User ID that added this member. */
     addedBy: Scalars['String']['output'];
+    /** Membership row identifier (ULID). */
     id: Scalars['String']['output'];
+    /** Recipient graph ID. */
     targetGraphId: Scalars['String']['output'];
+    /** Display name of the recipient graph (if known). */
     targetGraphName: Maybe<Scalars['String']['output']>;
+    /** Display name of the org that owns the recipient graph. */
     targetOrgName: Maybe<Scalars['String']['output']>;
 };
 export type Query = {
@@ -1142,33 +1592,67 @@ export type QueryTrialBalanceArgs = {
 export type QueryUnmappedElementsArgs = {
     mappingId?: InputMaybe<Scalars['String']['input']>;
 };
+/**
+ * Report definition summary — header metadata, no facts.
+ *
+ * Returned by ``create-report``, ``regenerate-report``,
+ * ``file-report``, and ``transition-filing-status``. Use the package
+ * read endpoint to retrieve a Report rehydrated with its rendered
+ * ``InformationBlockEnvelope`` items.
+ */
 export type Report = {
+    /** True when the report was created by an AI agent rather than a user. */
     aiGenerated: Scalars['Boolean']['output'];
+    /** True when an auto-generated prior-period column is included. */
     comparative: Scalars['Boolean']['output'];
+    /** When the report row was created. */
     createdAt: Scalars['DateTime']['output'];
+    /** Display name of the primary entity the report is tagged to. */
     entityName: Maybe<Scalars['String']['output']>;
+    /** When the report was transitioned to `filed`. */
     filedAt: Maybe<Scalars['DateTime']['output']>;
+    /** User ID that transitioned the report to `filed`. */
     filedBy: Maybe<Scalars['String']['output']>;
+    /** Filing lifecycle (orthogonal to `generation_status`): `draft`, `under_review`, `filed`, `archived`. */
     filingStatus: Scalars['String']['output'];
+    /** Computation lifecycle: `generating`, `published`, `failed`. Orthogonal to `filing_status`. */
     generationStatus: Scalars['String']['output'];
+    /** Report identifier (ULID). */
     id: Scalars['String']['output'];
+    /** When the facts were last (re)generated. */
     lastGenerated: Maybe<Scalars['DateTime']['output']>;
+    /** CoA → taxonomy mapping the facts were rolled up through. */
     mappingId: Maybe<Scalars['String']['output']>;
+    /** Human-readable report name. */
     name: Scalars['String']['output'];
+    /** Current-period end. */
     periodEnd: Maybe<Scalars['Date']['output']>;
+    /** Current-period start. */
     periodStart: Maybe<Scalars['Date']['output']>;
+    /** Period cadence: `monthly`, `quarterly`, `annual`. */
     periodType: Scalars['String']['output'];
+    /** Explicit period columns when the report was created with a multi-period layout. */
     periods: Maybe<Array<PeriodSpec>>;
+    /** Counts by rule outcome (e.g. `{'passed': 12, 'failed': 1}`) from the most recent evaluation. Null until rules run. */
     ruleSummary: Maybe<Scalars['JSON']['output']>;
+    /** When the report was shared into this graph (recipient side). */
     sharedAt: Maybe<Scalars['DateTime']['output']>;
+    /** Origin graph for received (shared) reports — populated only on the recipient's copy. */
     sourceGraphId: Maybe<Scalars['String']['output']>;
+    /** Origin report ID for received (shared) reports — populated only on the recipient's copy. */
     sourceReportId: Maybe<Scalars['String']['output']>;
+    /** Structures available for this report's taxonomy — renderable sections (BS / IS / CF / Equity / Schedules). */
     structures: Array<StructureSummary>;
+    /** When this report has been restated, the successor's report ID. */
     supersededById: Maybe<Scalars['String']['output']>;
+    /** When this report restates an earlier filing, the predecessor's report ID. */
     supersedesId: Maybe<Scalars['String']['output']>;
+    /** Taxonomy this report renders against. */
     taxonomyId: Scalars['String']['output'];
 };
+/** List of report header summaries (used by report list reads). */
 export type ReportList = {
+    /** Report definitions, newest first. */
     reports: Array<Report>;
 };
 export type ReportPackage = {
@@ -1220,25 +1704,60 @@ export type SecurityList = {
     pagination: PaginationInfo;
     securities: Array<Security>;
 };
+/**
+ * Lightweight security projection for embedding in position
+ * envelopes. Skips `terms`, `outstanding_shares`, etc. — fetch the
+ * full `SecurityResponse` when those are needed.
+ */
 export type SecurityLite = {
+    /** Security ID (`sec_*` ULID). */
     id: Scalars['ID']['output'];
+    /** `true` when the security is in active status. */
     isActive: Scalars['Boolean']['output'];
+    /** Embedded issuer entity, when one is linked. `null` for pre-issuer securities. */
     issuer: Maybe<EntityLite>;
+    /** Display name of the security. */
     name: Scalars['String']['output'];
+    /** Optional subtype refinement (e.g. `class_a`). */
     securitySubtype: Maybe<Scalars['String']['output']>;
+    /** Instrument family (e.g. `common_stock`, `preferred_stock`, `warrant`). */
     securityType: Scalars['String']['output'];
+    /** Tenant graph the security is pre-associated to, if any. */
     sourceGraphId: Maybe<Scalars['String']['output']>;
 };
+/**
+ * Rendered financial statement — facts viewed through a structure.
+ *
+ * Returned by report read endpoints when a single statement is
+ * requested. The package mode endpoint returns a list of these
+ * rehydrated as ``InformationBlockEnvelope`` items instead.
+ */
 export type Statement = {
+    /** Period columns rendered in this statement, in display order. */
     periods: Array<PeriodSpec>;
+    /** The Report this statement was rendered from. */
     reportId: Scalars['String']['output'];
+    /** One row per concept in the structure, in tree order. */
     rows: Array<FactRow>;
+    /** Structure projected for this statement. */
     structureId: Scalars['String']['output'];
+    /** Human-readable structure name. */
     structureName: Scalars['String']['output'];
+    /** Structure category: `balance_sheet`, `income_statement`, `cash_flow_statement`, `equity_statement`, `schedule`. */
     structureType: Scalars['String']['output'];
+    /** Number of GL elements that fell through the mapping with no destination concept. Indicates mapping gaps. */
     unmappedCount: Scalars['Int']['output'];
+    /** Outcome of running reporting rules over this structure. Null when the structure has no rules attached. */
     validation: Maybe<ValidationCheck>;
 };
+/**
+ * One structure header — a renderable section within a taxonomy
+ * (balance sheet, income statement, schedule, etc.).
+ *
+ * ``structure_type`` drives presentation: 'balance_sheet',
+ * 'income_statement', 'cash_flow_statement', 'equity_statement',
+ * 'schedule', 'chart_of_accounts', 'coa_mapping', 'rollforward', etc.
+ */
 export type Structure = {
     description: Maybe<Scalars['String']['output']>;
     id: Scalars['String']['output'];
@@ -1247,20 +1766,43 @@ export type Structure = {
     structureType: Scalars['String']['output'];
     taxonomyId: Scalars['String']['output'];
 };
+/** Flat list of structures within a taxonomy. */
 export type StructureList = {
     structures: Array<Structure>;
 };
+/**
+ * A structure available within this report's taxonomy.
+ *
+ * Each structure is a renderable section (Balance Sheet, Income
+ * Statement, Cash Flow Statement, Equity, or a Schedule). The Report
+ * row owns the facts; structures are the lenses that project them.
+ */
 export type StructureSummary = {
+    /** Structure identifier. */
     id: Scalars['String']['output'];
+    /** Human-readable structure name. */
     name: Scalars['String']['output'];
+    /** Structure category: `balance_sheet`, `income_statement`, `cash_flow_statement`, `equity_statement`, `schedule`. */
     structureType: Scalars['String']['output'];
 };
+/** A suggested mapping target from the reporting taxonomy. */
 export type SuggestedTarget = {
     confidence: Maybe<Scalars['Float']['output']>;
     elementId: Scalars['String']['output'];
     name: Scalars['String']['output'];
     qname: Scalars['String']['output'];
 };
+/**
+ * One taxonomy header — identity + lifecycle flags. Atoms
+ * (elements, structures, associations, rules) are exposed via the
+ * Taxonomy Block envelope.
+ *
+ * ``taxonomy_type`` discriminates: ``chart_of_accounts``,
+ * ``reporting_standard``, ``reporting_extension``, ``custom_ontology``,
+ * ``mapping``, ``schedule``. ``is_locked=True`` means library-origin
+ * (immutable for tenants); ``is_shared=True`` means visible to multiple
+ * graphs from a shared registry.
+ */
 export type Taxonomy = {
     description: Maybe<Scalars['String']['output']>;
     id: Scalars['String']['output'];
@@ -1337,14 +1879,24 @@ export type TaxonomyBlockStructure = {
     roleUri: Maybe<Scalars['String']['output']>;
     structureType: Scalars['String']['output'];
 };
+/** Flat list of taxonomy headers. Used by the catalog/picker UIs. */
 export type TaxonomyList = {
     taxonomies: Array<Taxonomy>;
 };
+/**
+ * Trial balance for posted entries in a date range — every CoA
+ * account that had activity, plus aggregate totals.
+ *
+ * Ledger is balanced when ``total_debits == total_credits``. Used as
+ * a sanity check before close-period; failure means an unposted /
+ * malformed entry slipped through.
+ */
 export type TrialBalance = {
     rows: Array<TrialBalanceRow>;
     totalCredits: Scalars['Float']['output'];
     totalDebits: Scalars['Float']['output'];
 };
+/** One CoA account's debit/credit totals over the trial-balance window. */
 export type TrialBalanceRow = {
     accountCode: Scalars['String']['output'];
     accountId: Scalars['String']['output'];
@@ -1355,6 +1907,7 @@ export type TrialBalanceRow = {
     totalDebits: Scalars['Float']['output'];
     trait: Maybe<Scalars['String']['output']>;
 };
+/** An element not yet mapped to the reporting taxonomy. */
 export type UnmappedElement = {
     balanceType: Scalars['String']['output'];
     code: Maybe<Scalars['String']['output']>;
@@ -1364,10 +1917,15 @@ export type UnmappedElement = {
     suggestedTargets: Array<SuggestedTarget>;
     trait: Maybe<Scalars['String']['output']>;
 };
+/** Aggregate result of running reporting rules over a structure. */
 export type ValidationCheck = {
+    /** Names of rules that were evaluated. */
     checks: Array<Scalars['String']['output']>;
+    /** Human-readable descriptions of rule failures. */
     failures: Array<Scalars['String']['output']>;
+    /** True iff every rule produced zero failures. */
     passed: Scalars['Boolean']['output'];
+    /** Non-blocking advisories from rule evaluation. */
     warnings: Array<Scalars['String']['output']>;
 };
 export type GetInvestorHoldingsQueryVariables = Exact<{