@robosystems/client 0.2.48 → 0.3.0

package/extensions/graphql/generated/graphql.d.ts

@@ -0,0 +1,1786 @@
+import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Date: {
+        input: any;
+        output: any;
+    };
+    DateTime: {
+        input: any;
+        output: any;
+    };
+    JSON: {
+        input: any;
+        output: any;
+    };
+};
+export type Account = {
+    accountType: Maybe<Scalars['String']['output']>;
+    balanceType: Scalars['String']['output'];
+    classification: Scalars['String']['output'];
+    code: Maybe<Scalars['String']['output']>;
+    currency: Scalars['String']['output'];
+    depth: Scalars['Int']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    externalId: Maybe<Scalars['String']['output']>;
+    externalSource: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    isActive: Scalars['Boolean']['output'];
+    isPlaceholder: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    parentId: Maybe<Scalars['String']['output']>;
+    subClassification: Maybe<Scalars['String']['output']>;
+};
+export type AccountList = {
+    accounts: Array<Account>;
+    pagination: PaginationInfo;
+};
+export type AccountRollupGroup = {
+    accounts: Array<AccountRollupRow>;
+    balanceType: Scalars['String']['output'];
+    classification: Scalars['String']['output'];
+    reportingElementId: Scalars['String']['output'];
+    reportingName: Scalars['String']['output'];
+    reportingQname: Scalars['String']['output'];
+    total: Scalars['Float']['output'];
+};
+export type AccountRollupRow = {
+    accountCode: Maybe<Scalars['String']['output']>;
+    accountName: Scalars['String']['output'];
+    elementId: Scalars['String']['output'];
+    netBalance: Scalars['Float']['output'];
+    totalCredits: Scalars['Float']['output'];
+    totalDebits: Scalars['Float']['output'];
+};
+export type AccountRollups = {
+    groups: Array<AccountRollupGroup>;
+    mappingId: Scalars['String']['output'];
+    mappingName: Scalars['String']['output'];
+    totalMapped: Scalars['Int']['output'];
+    totalUnmapped: Scalars['Int']['output'];
+};
+export type AccountTree = {
+    roots: Array<AccountTreeNode>;
+    totalAccounts: Scalars['Int']['output'];
+};
+export type AccountTreeNode = {
+    accountType: Maybe<Scalars['String']['output']>;
+    balanceType: Scalars['String']['output'];
+    children: Array<AccountTreeNode>;
+    classification: Scalars['String']['output'];
+    code: Maybe<Scalars['String']['output']>;
+    depth: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    isActive: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+};
+export type Association = {
+    approvedBy: Maybe<Scalars['String']['output']>;
+    associationType: Scalars['String']['output'];
+    confidence: Maybe<Scalars['Float']['output']>;
+    fromElementId: Scalars['String']['output'];
+    fromElementName: Maybe<Scalars['String']['output']>;
+    fromElementQname: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    orderValue: Maybe<Scalars['Float']['output']>;
+    structureId: Scalars['String']['output'];
+    suggestedBy: Maybe<Scalars['String']['output']>;
+    toElementId: Scalars['String']['output'];
+    toElementName: Maybe<Scalars['String']['output']>;
+    toElementQname: Maybe<Scalars['String']['output']>;
+    weight: Maybe<Scalars['Float']['output']>;
+};
+export type ClosingBookCategory = {
+    items: Array<ClosingBookItem>;
+    label: Scalars['String']['output'];
+};
+export type ClosingBookItem = {
+    id: Scalars['String']['output'];
+    itemType: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    reportId: Maybe<Scalars['String']['output']>;
+    status: Maybe<Scalars['String']['output']>;
+    structureType: Maybe<Scalars['String']['output']>;
+};
+export type ClosingBookStructures = {
+    categories: Array<ClosingBookCategory>;
+    hasData: Scalars['Boolean']['output'];
+};
+export type DraftEntry = {
+    /** True if total_debit == total_credit */
+    balanced: Scalars['Boolean']['output'];
+    entryId: Scalars['String']['output'];
+    lineItems: Array<DraftLineItem>;
+    memo: Maybe<Scalars['String']['output']>;
+    postingDate: Scalars['Date']['output'];
+    /** Where the entry came from: 'ai_generated', 'manual_entry', etc. */
+    provenance: Maybe<Scalars['String']['output']>;
+    /** Schedule structure that generated this entry (if any) */
+    sourceStructureId: Maybe<Scalars['String']['output']>;
+    /** Human-readable name of the source schedule */
+    sourceStructureName: Maybe<Scalars['String']['output']>;
+    /** Sum of credit amounts in cents */
+    totalCredit: Scalars['Int']['output'];
+    /** Sum of debit amounts in cents */
+    totalDebit: Scalars['Int']['output'];
+    /** Entry type (e.g., 'closing', 'adjusting') */
+    type: Scalars['String']['output'];
+};
+export type DraftLineItem = {
+    /** Credit amount in cents */
+    creditAmount: Scalars['Int']['output'];
+    /** Debit amount in cents */
+    debitAmount: Scalars['Int']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    elementCode: Maybe<Scalars['String']['output']>;
+    elementId: Scalars['String']['output'];
+    elementName: Scalars['String']['output'];
+    lineItemId: Scalars['String']['output'];
+};
+export type Element = {
+    balanceType: Scalars['String']['output'];
+    classification: Scalars['String']['output'];
+    code: Maybe<Scalars['String']['output']>;
+    depth: Scalars['Int']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    elementType: Scalars['String']['output'];
+    externalId: Maybe<Scalars['String']['output']>;
+    externalSource: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    isAbstract: Scalars['Boolean']['output'];
+    isActive: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    namespace: Maybe<Scalars['String']['output']>;
+    parentId: Maybe<Scalars['String']['output']>;
+    periodType: Scalars['String']['output'];
+    qname: Maybe<Scalars['String']['output']>;
+    source: Scalars['String']['output'];
+    subClassification: Maybe<Scalars['String']['output']>;
+    taxonomyId: Maybe<Scalars['String']['output']>;
+};
+export type ElementList = {
+    elements: Array<Element>;
+    pagination: PaginationInfo;
+};
+export type FactRow = {
+    classification: Scalars['String']['output'];
+    depth: Scalars['Int']['output'];
+    elementId: Scalars['String']['output'];
+    elementName: Scalars['String']['output'];
+    elementQname: Scalars['String']['output'];
+    isSubtotal: Scalars['Boolean']['output'];
+    values: Array<Maybe<Scalars['Float']['output']>>;
+};
+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']>;
+    /** Ordered list of periods that a close run would process */
+    catchUpSequence: Array<Scalars['String']['output']>;
+    /** Target period the user wants closed through (YYYY-MM) */
+    closeTarget: Maybe<Scalars['String']['output']>;
+    /** Whether the next period in the catch-up sequence passes all closeable gates */
+    closeableNow: Scalars['Boolean']['output'];
+    /** Latest closed period (YYYY-MM), or null if nothing closed */
+    closedThrough: Maybe<Scalars['String']['output']>;
+    fiscalYearStartMonth: Scalars['Int']['output'];
+    /** Number of periods between closed_through and close_target (inclusive of close_target). 0 means caught up. */
+    gapPeriods: Scalars['Int']['output'];
+    graphId: Scalars['String']['output'];
+    initializedAt: Maybe<Scalars['DateTime']['output']>;
+    lastCloseAt: Maybe<Scalars['DateTime']['output']>;
+    /** Most recent QB sync timestamp (if connected) */
+    lastSyncAt: Maybe<Scalars['DateTime']['output']>;
+    /** Fiscal period rows for this graph */
+    periods: Array<FiscalPeriodSummary>;
+};
+export type FiscalPeriodSummary = {
+    closedAt: Maybe<Scalars['DateTime']['output']>;
+    endDate: Scalars['Date']['output'];
+    /** Period name (YYYY-MM) */
+    name: Scalars['String']['output'];
+    startDate: Scalars['Date']['output'];
+    /** 'open' | 'closing' | 'closed' */
+    status: Scalars['String']['output'];
+};
+export type Holding = {
+    entityId: Scalars['String']['output'];
+    entityName: Scalars['String']['output'];
+    positionCount: Scalars['Int']['output'];
+    securities: Array<HoldingSecuritySummary>;
+    sourceGraphId: Maybe<Scalars['String']['output']>;
+    totalCostBasisDollars: Scalars['Float']['output'];
+    totalCurrentValueDollars: Maybe<Scalars['Float']['output']>;
+};
+export type HoldingSecuritySummary = {
+    costBasisDollars: Scalars['Float']['output'];
+    currentValueDollars: Maybe<Scalars['Float']['output']>;
+    quantity: Scalars['Float']['output'];
+    quantityType: Scalars['String']['output'];
+    securityId: Scalars['String']['output'];
+    securityName: Scalars['String']['output'];
+    securityType: Scalars['String']['output'];
+};
+export type HoldingsList = {
+    holdings: Array<Holding>;
+    totalEntities: Scalars['Int']['output'];
+    totalPositions: Scalars['Int']['output'];
+};
+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']>;
+    category: Maybe<Scalars['String']['output']>;
+    cik: Maybe<Scalars['String']['output']>;
+    connectionId: Maybe<Scalars['String']['output']>;
+    createdAt: Maybe<Scalars['String']['output']>;
+    entityType: Maybe<Scalars['String']['output']>;
+    exchange: Maybe<Scalars['String']['output']>;
+    fiscalYearEnd: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    industry: Maybe<Scalars['String']['output']>;
+    isParent: Scalars['Boolean']['output'];
+    legalName: Maybe<Scalars['String']['output']>;
+    lei: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    parentEntityId: Maybe<Scalars['String']['output']>;
+    phone: Maybe<Scalars['String']['output']>;
+    sic: Maybe<Scalars['String']['output']>;
+    sicDescription: Maybe<Scalars['String']['output']>;
+    source: Scalars['String']['output'];
+    sourceGraphId: Maybe<Scalars['String']['output']>;
+    sourceId: Maybe<Scalars['String']['output']>;
+    stateOfIncorporation: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    taxId: Maybe<Scalars['String']['output']>;
+    ticker: Maybe<Scalars['String']['output']>;
+    updatedAt: Maybe<Scalars['String']['output']>;
+    uri: Maybe<Scalars['String']['output']>;
+    website: Maybe<Scalars['String']['output']>;
+};
+export type LedgerEntry = {
+    id: Scalars['String']['output'];
+    lineItems: Array<LedgerLineItem>;
+    memo: Maybe<Scalars['String']['output']>;
+    number: Maybe<Scalars['String']['output']>;
+    postedAt: Maybe<Scalars['DateTime']['output']>;
+    postingDate: Scalars['Date']['output'];
+    status: Scalars['String']['output'];
+    type: Scalars['String']['output'];
+};
+export type LedgerLineItem = {
+    accountCode: Maybe<Scalars['String']['output']>;
+    accountId: Scalars['String']['output'];
+    accountName: Maybe<Scalars['String']['output']>;
+    creditAmount: Scalars['Float']['output'];
+    debitAmount: Scalars['Float']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    lineOrder: Scalars['Int']['output'];
+};
+export type LedgerSummary = {
+    accountCount: Scalars['Int']['output'];
+    connectionCount: Scalars['Int']['output'];
+    earliestTransactionDate: Maybe<Scalars['Date']['output']>;
+    entryCount: Scalars['Int']['output'];
+    graphId: Scalars['String']['output'];
+    lastSyncAt: Maybe<Scalars['DateTime']['output']>;
+    latestTransactionDate: Maybe<Scalars['Date']['output']>;
+    lineItemCount: Scalars['Int']['output'];
+    transactionCount: Scalars['Int']['output'];
+};
+export type LedgerTransactionDetail = {
+    amount: Scalars['Float']['output'];
+    category: Maybe<Scalars['String']['output']>;
+    currency: Scalars['String']['output'];
+    date: Scalars['Date']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    dueDate: Maybe<Scalars['Date']['output']>;
+    entries: Array<LedgerEntry>;
+    id: Scalars['String']['output'];
+    merchantName: Maybe<Scalars['String']['output']>;
+    number: Maybe<Scalars['String']['output']>;
+    postedAt: Maybe<Scalars['DateTime']['output']>;
+    referenceNumber: Maybe<Scalars['String']['output']>;
+    source: Scalars['String']['output'];
+    sourceId: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    type: Scalars['String']['output'];
+};
+export type LedgerTransactionList = {
+    pagination: PaginationInfo;
+    transactions: Array<LedgerTransactionSummary>;
+};
+export type LedgerTransactionSummary = {
+    amount: Scalars['Float']['output'];
+    category: Maybe<Scalars['String']['output']>;
+    currency: Scalars['String']['output'];
+    date: Scalars['Date']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    dueDate: Maybe<Scalars['Date']['output']>;
+    id: Scalars['String']['output'];
+    merchantName: Maybe<Scalars['String']['output']>;
+    number: Maybe<Scalars['String']['output']>;
+    referenceNumber: Maybe<Scalars['String']['output']>;
+    source: Scalars['String']['output'];
+    status: Scalars['String']['output'];
+    type: Scalars['String']['output'];
+};
+export type MappedTrialBalance = {
+    mappingId: Scalars['String']['output'];
+    rows: Array<MappedTrialBalanceRow>;
+};
+export type MappedTrialBalanceRow = {
+    balanceType: Maybe<Scalars['String']['output']>;
+    classification: Maybe<Scalars['String']['output']>;
+    netBalance: Scalars['Float']['output'];
+    qname: Scalars['String']['output'];
+    reportingElementId: Scalars['String']['output'];
+    reportingName: Scalars['String']['output'];
+    totalCredits: Scalars['Float']['output'];
+    totalDebits: Scalars['Float']['output'];
+};
+export type MappingCoverage = {
+    coveragePercent: Scalars['Float']['output'];
+    highConfidence: Scalars['Int']['output'];
+    lowConfidence: Scalars['Int']['output'];
+    mappedCount: Scalars['Int']['output'];
+    mappingId: Scalars['String']['output'];
+    mediumConfidence: Scalars['Int']['output'];
+    totalCoaElements: Scalars['Int']['output'];
+    unmappedCount: Scalars['Int']['output'];
+};
+export type MappingDetail = {
+    associations: Array<Association>;
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    structureType: Scalars['String']['output'];
+    taxonomyId: Scalars['String']['output'];
+    totalAssociations: Scalars['Int']['output'];
+};
+export type PaginationInfo = {
+    /** Whether more items are available */
+    hasMore: Scalars['Boolean']['output'];
+    /** Maximum number of items returned in this response */
+    limit: Scalars['Int']['output'];
+    /** Number of items skipped */
+    offset: Scalars['Int']['output'];
+    /** Total number of items available */
+    total: Scalars['Int']['output'];
+};
+export type PeriodCloseItem = {
+    amount: Scalars['Float']['output'];
+    entryId: Maybe<Scalars['String']['output']>;
+    reversalEntryId: Maybe<Scalars['String']['output']>;
+    reversalStatus: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    structureId: Scalars['String']['output'];
+    structureName: Scalars['String']['output'];
+};
+export type PeriodCloseStatus = {
+    fiscalPeriodEnd: Scalars['Date']['output'];
+    fiscalPeriodStart: Scalars['Date']['output'];
+    periodStatus: Scalars['String']['output'];
+    schedules: Array<PeriodCloseItem>;
+    totalDraft: Scalars['Int']['output'];
+    totalPosted: Scalars['Int']['output'];
+};
+export type PeriodDrafts = {
+    /** True if every draft entry has debit == credit */
+    allBalanced: Scalars['Boolean']['output'];
+    draftCount: Scalars['Int']['output'];
+    drafts: Array<DraftEntry>;
+    /** YYYY-MM period name */
+    period: Scalars['String']['output'];
+    periodEnd: Scalars['Date']['output'];
+    periodStart: Scalars['Date']['output'];
+    /** Sum across all drafts, in cents */
+    totalCredit: Scalars['Int']['output'];
+    /** Sum across all drafts, in cents */
+    totalDebit: Scalars['Int']['output'];
+};
+export type PeriodSpec = {
+    end: Scalars['Date']['output'];
+    label: Scalars['String']['output'];
+    start: Scalars['Date']['output'];
+};
+export type Portfolio = {
+    baseCurrency: Scalars['String']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    inceptionDate: Maybe<Scalars['Date']['output']>;
+    name: Scalars['String']['output'];
+    strategy: Maybe<Scalars['String']['output']>;
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type PortfolioList = {
+    pagination: PaginationInfo;
+    portfolios: Array<Portfolio>;
+};
+export type Position = {
+    acquisitionDate: Maybe<Scalars['Date']['output']>;
+    costBasis: Scalars['Int']['output'];
+    costBasisDollars: Scalars['Float']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    currency: Scalars['String']['output'];
+    currentValue: Maybe<Scalars['Int']['output']>;
+    currentValueDollars: Maybe<Scalars['Float']['output']>;
+    dispositionDate: Maybe<Scalars['Date']['output']>;
+    entityName: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    notes: Maybe<Scalars['String']['output']>;
+    portfolioId: Scalars['String']['output'];
+    quantity: Scalars['Float']['output'];
+    quantityType: Scalars['String']['output'];
+    securityId: Scalars['String']['output'];
+    securityName: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+    valuationDate: Maybe<Scalars['Date']['output']>;
+    valuationSource: Maybe<Scalars['String']['output']>;
+};
+export type PositionList = {
+    pagination: PaginationInfo;
+    positions: Array<Position>;
+};
+export type PublishList = {
+    createdAt: Scalars['DateTime']['output'];
+    createdBy: Scalars['String']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    memberCount: Scalars['Int']['output'];
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type PublishListDetail = {
+    createdAt: Scalars['DateTime']['output'];
+    createdBy: Scalars['String']['output'];
+    description: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    memberCount: Scalars['Int']['output'];
+    members: Array<PublishListMember>;
+    name: Scalars['String']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type PublishListList = {
+    pagination: PaginationInfo;
+    publishLists: Array<PublishList>;
+};
+export type PublishListMember = {
+    addedAt: Scalars['DateTime']['output'];
+    addedBy: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    targetGraphId: Scalars['String']['output'];
+    targetGraphName: Maybe<Scalars['String']['output']>;
+    targetOrgName: Maybe<Scalars['String']['output']>;
+};
+export type Query = {
+    accountRollups: Maybe<AccountRollups>;
+    accountTree: Maybe<AccountTree>;
+    accounts: Maybe<AccountList>;
+    closingBookStructures: Maybe<ClosingBookStructures>;
+    elements: Maybe<ElementList>;
+    entities: Array<LedgerEntity>;
+    entity: Maybe<LedgerEntity>;
+    fiscalCalendar: Maybe<FiscalCalendar>;
+    hello: Scalars['String']['output'];
+    holdings: Maybe<HoldingsList>;
+    mappedTrialBalance: Maybe<MappedTrialBalance>;
+    mapping: Maybe<MappingDetail>;
+    mappingCoverage: Maybe<MappingCoverage>;
+    mappings: Maybe<StructureList>;
+    periodCloseStatus: Maybe<PeriodCloseStatus>;
+    periodDrafts: Maybe<PeriodDrafts>;
+    portfolio: Maybe<Portfolio>;
+    portfolios: Maybe<PortfolioList>;
+    position: Maybe<Position>;
+    positions: Maybe<PositionList>;
+    publishList: Maybe<PublishListDetail>;
+    publishLists: Maybe<PublishListList>;
+    report: Maybe<Report>;
+    reportingTaxonomy: Maybe<Taxonomy>;
+    reports: Maybe<ReportList>;
+    scheduleFacts: Maybe<ScheduleFacts>;
+    schedules: Maybe<ScheduleList>;
+    securities: Maybe<SecurityList>;
+    security: Maybe<Security>;
+    statement: Maybe<Statement>;
+    structures: Maybe<StructureList>;
+    summary: Maybe<LedgerSummary>;
+    taxonomies: Maybe<TaxonomyList>;
+    transaction: Maybe<LedgerTransactionDetail>;
+    transactions: Maybe<LedgerTransactionList>;
+    trialBalance: Maybe<TrialBalance>;
+    unmappedElements: Array<UnmappedElement>;
+};
+export type QueryAccountRollupsArgs = {
+    endDate?: InputMaybe<Scalars['Date']['input']>;
+    mappingId?: InputMaybe<Scalars['String']['input']>;
+    startDate?: InputMaybe<Scalars['Date']['input']>;
+};
+export type QueryAccountsArgs = {
+    classification?: InputMaybe<Scalars['String']['input']>;
+    isActive?: InputMaybe<Scalars['Boolean']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+};
+export type QueryElementsArgs = {
+    classification?: InputMaybe<Scalars['String']['input']>;
+    isAbstract?: InputMaybe<Scalars['Boolean']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+    source?: InputMaybe<Scalars['String']['input']>;
+    taxonomyId?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryEntitiesArgs = {
+    source?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryHoldingsArgs = {
+    portfolioId: Scalars['String']['input'];
+};
+export type QueryMappedTrialBalanceArgs = {
+    endDate?: InputMaybe<Scalars['Date']['input']>;
+    mappingId: Scalars['String']['input'];
+    startDate?: InputMaybe<Scalars['Date']['input']>;
+};
+export type QueryMappingArgs = {
+    mappingId: Scalars['String']['input'];
+};
+export type QueryMappingCoverageArgs = {
+    mappingId: Scalars['String']['input'];
+};
+export type QueryPeriodCloseStatusArgs = {
+    periodEnd: Scalars['Date']['input'];
+    periodStart: Scalars['Date']['input'];
+};
+export type QueryPeriodDraftsArgs = {
+    period: Scalars['String']['input'];
+};
+export type QueryPortfolioArgs = {
+    portfolioId: Scalars['String']['input'];
+};
+export type QueryPortfoliosArgs = {
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+};
+export type QueryPositionArgs = {
+    positionId: Scalars['String']['input'];
+};
+export type QueryPositionsArgs = {
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+    portfolioId?: InputMaybe<Scalars['String']['input']>;
+    securityId?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryPublishListArgs = {
+    listId: Scalars['String']['input'];
+};
+export type QueryPublishListsArgs = {
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+};
+export type QueryReportArgs = {
+    reportId: Scalars['String']['input'];
+};
+export type QueryScheduleFactsArgs = {
+    periodEnd?: InputMaybe<Scalars['Date']['input']>;
+    periodStart?: InputMaybe<Scalars['Date']['input']>;
+    structureId: Scalars['String']['input'];
+};
+export type QuerySecuritiesArgs = {
+    entityId?: InputMaybe<Scalars['String']['input']>;
+    isActive?: InputMaybe<Scalars['Boolean']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+    securityType?: InputMaybe<Scalars['String']['input']>;
+};
+export type QuerySecurityArgs = {
+    securityId: Scalars['String']['input'];
+};
+export type QueryStatementArgs = {
+    reportId: Scalars['String']['input'];
+    structureType: Scalars['String']['input'];
+};
+export type QueryStructuresArgs = {
+    structureType?: InputMaybe<Scalars['String']['input']>;
+    taxonomyId?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryTaxonomiesArgs = {
+    taxonomyType?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryTransactionArgs = {
+    transactionId: Scalars['String']['input'];
+};
+export type QueryTransactionsArgs = {
+    endDate?: InputMaybe<Scalars['Date']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+    startDate?: InputMaybe<Scalars['Date']['input']>;
+    type?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryTrialBalanceArgs = {
+    endDate?: InputMaybe<Scalars['Date']['input']>;
+    startDate?: InputMaybe<Scalars['Date']['input']>;
+};
+export type QueryUnmappedElementsArgs = {
+    mappingId?: InputMaybe<Scalars['String']['input']>;
+};
+export type Report = {
+    aiGenerated: Scalars['Boolean']['output'];
+    comparative: Scalars['Boolean']['output'];
+    createdAt: Scalars['DateTime']['output'];
+    entityName: Maybe<Scalars['String']['output']>;
+    generationStatus: Scalars['String']['output'];
+    id: Scalars['String']['output'];
+    lastGenerated: Maybe<Scalars['DateTime']['output']>;
+    mappingId: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    periodEnd: Maybe<Scalars['Date']['output']>;
+    periodStart: Maybe<Scalars['Date']['output']>;
+    periodType: Scalars['String']['output'];
+    periods: Maybe<Array<PeriodSpec>>;
+    sharedAt: Maybe<Scalars['DateTime']['output']>;
+    sourceGraphId: Maybe<Scalars['String']['output']>;
+    sourceReportId: Maybe<Scalars['String']['output']>;
+    structures: Array<StructureSummary>;
+    taxonomyId: Scalars['String']['output'];
+};
+export type ReportList = {
+    reports: Array<Report>;
+};
+export type ScheduleFact = {
+    elementId: Scalars['String']['output'];
+    elementName: Scalars['String']['output'];
+    periodEnd: Scalars['Date']['output'];
+    periodStart: Scalars['Date']['output'];
+    value: Scalars['Float']['output'];
+};
+export type ScheduleFacts = {
+    facts: Array<ScheduleFact>;
+    structureId: Scalars['String']['output'];
+};
+export type ScheduleList = {
+    schedules: Array<ScheduleSummary>;
+};
+export type ScheduleSummary = {
+    entryTemplate: Maybe<Scalars['JSON']['output']>;
+    name: Scalars['String']['output'];
+    periodsWithEntries: Scalars['Int']['output'];
+    scheduleMetadata: Maybe<Scalars['JSON']['output']>;
+    structureId: Scalars['ID']['output'];
+    taxonomyName: Scalars['String']['output'];
+    totalPeriods: Scalars['Int']['output'];
+};
+export type Security = {
+    authorizedShares: Maybe<Scalars['Int']['output']>;
+    createdAt: Scalars['DateTime']['output'];
+    entityId: Maybe<Scalars['String']['output']>;
+    entityName: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    isActive: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    outstandingShares: Maybe<Scalars['Int']['output']>;
+    securitySubtype: Maybe<Scalars['String']['output']>;
+    securityType: Scalars['String']['output'];
+    sourceGraphId: Maybe<Scalars['String']['output']>;
+    terms: Scalars['JSON']['output'];
+    updatedAt: Scalars['DateTime']['output'];
+};
+export type SecurityList = {
+    pagination: PaginationInfo;
+    securities: Array<Security>;
+};
+export type Statement = {
+    periods: Array<PeriodSpec>;
+    reportId: Scalars['String']['output'];
+    rows: Array<FactRow>;
+    structureId: Scalars['String']['output'];
+    structureName: Scalars['String']['output'];
+    structureType: Scalars['String']['output'];
+    unmappedCount: Scalars['Int']['output'];
+    validation: Maybe<ValidationCheck>;
+};
+export type Structure = {
+    description: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    isActive: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    structureType: Scalars['String']['output'];
+    taxonomyId: Scalars['String']['output'];
+};
+export type StructureList = {
+    structures: Array<Structure>;
+};
+export type StructureSummary = {
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    structureType: Scalars['String']['output'];
+};
+export type SuggestedTarget = {
+    confidence: Maybe<Scalars['Float']['output']>;
+    elementId: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    qname: Scalars['String']['output'];
+};
+export type Taxonomy = {
+    description: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    isActive: Scalars['Boolean']['output'];
+    isLocked: Scalars['Boolean']['output'];
+    isShared: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    namespaceUri: Maybe<Scalars['String']['output']>;
+    sourceTaxonomyId: Maybe<Scalars['String']['output']>;
+    standard: Maybe<Scalars['String']['output']>;
+    targetTaxonomyId: Maybe<Scalars['String']['output']>;
+    taxonomyType: Scalars['String']['output'];
+    version: Maybe<Scalars['String']['output']>;
+};
+export type TaxonomyList = {
+    taxonomies: Array<Taxonomy>;
+};
+export type TrialBalance = {
+    rows: Array<TrialBalanceRow>;
+    totalCredits: Scalars['Float']['output'];
+    totalDebits: Scalars['Float']['output'];
+};
+export type TrialBalanceRow = {
+    accountCode: Scalars['String']['output'];
+    accountId: Scalars['String']['output'];
+    accountName: Scalars['String']['output'];
+    accountType: Maybe<Scalars['String']['output']>;
+    classification: Scalars['String']['output'];
+    netBalance: Scalars['Float']['output'];
+    totalCredits: Scalars['Float']['output'];
+    totalDebits: Scalars['Float']['output'];
+};
+export type UnmappedElement = {
+    balanceType: Scalars['String']['output'];
+    classification: Scalars['String']['output'];
+    code: Maybe<Scalars['String']['output']>;
+    externalSource: Maybe<Scalars['String']['output']>;
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    suggestedTargets: Array<SuggestedTarget>;
+};
+export type ValidationCheck = {
+    checks: Array<Scalars['String']['output']>;
+    failures: Array<Scalars['String']['output']>;
+    passed: Scalars['Boolean']['output'];
+    warnings: Array<Scalars['String']['output']>;
+};
+export type GetInvestorHoldingsQueryVariables = Exact<{
+    portfolioId: Scalars['String']['input'];
+}>;
+export type GetInvestorHoldingsQuery = {
+    holdings: {
+        totalEntities: number;
+        totalPositions: number;
+        holdings: Array<{
+            entityId: string;
+            entityName: string;
+            sourceGraphId: string | null;
+            totalCostBasisDollars: number;
+            totalCurrentValueDollars: number | null;
+            positionCount: number;
+            securities: Array<{
+                securityId: string;
+                securityName: string;
+                securityType: string;
+                quantity: number;
+                quantityType: string;
+                costBasisDollars: number;
+                currentValueDollars: number | null;
+            }>;
+        }>;
+    } | null;
+};
+export type GetInvestorPortfolioQueryVariables = Exact<{
+    portfolioId: Scalars['String']['input'];
+}>;
+export type GetInvestorPortfolioQuery = {
+    portfolio: {
+        id: string;
+        name: string;
+        description: string | null;
+        strategy: string | null;
+        inceptionDate: any | null;
+        baseCurrency: string;
+        createdAt: any;
+        updatedAt: any;
+    } | null;
+};
+export type ListInvestorPortfoliosQueryVariables = Exact<{
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListInvestorPortfoliosQuery = {
+    portfolios: {
+        portfolios: Array<{
+            id: string;
+            name: string;
+            description: string | null;
+            strategy: string | null;
+            inceptionDate: any | null;
+            baseCurrency: string;
+            createdAt: any;
+            updatedAt: any;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type GetInvestorPositionQueryVariables = Exact<{
+    positionId: Scalars['String']['input'];
+}>;
+export type GetInvestorPositionQuery = {
+    position: {
+        id: string;
+        portfolioId: string;
+        securityId: string;
+        securityName: string | null;
+        entityName: string | null;
+        quantity: number;
+        quantityType: string;
+        costBasis: number;
+        costBasisDollars: number;
+        currency: string;
+        currentValue: number | null;
+        currentValueDollars: number | null;
+        valuationDate: any | null;
+        valuationSource: string | null;
+        acquisitionDate: any | null;
+        dispositionDate: any | null;
+        status: string;
+        notes: string | null;
+        createdAt: any;
+        updatedAt: any;
+    } | null;
+};
+export type ListInvestorPositionsQueryVariables = Exact<{
+    portfolioId: InputMaybe<Scalars['String']['input']>;
+    securityId: InputMaybe<Scalars['String']['input']>;
+    status: InputMaybe<Scalars['String']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListInvestorPositionsQuery = {
+    positions: {
+        positions: Array<{
+            id: string;
+            portfolioId: string;
+            securityId: string;
+            securityName: string | null;
+            entityName: string | null;
+            quantity: number;
+            quantityType: string;
+            costBasis: number;
+            costBasisDollars: number;
+            currency: string;
+            currentValue: number | null;
+            currentValueDollars: number | null;
+            valuationDate: any | null;
+            valuationSource: string | null;
+            acquisitionDate: any | null;
+            dispositionDate: any | null;
+            status: string;
+            notes: string | null;
+            createdAt: any;
+            updatedAt: any;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type ListInvestorSecuritiesQueryVariables = Exact<{
+    entityId: InputMaybe<Scalars['String']['input']>;
+    securityType: InputMaybe<Scalars['String']['input']>;
+    isActive: InputMaybe<Scalars['Boolean']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListInvestorSecuritiesQuery = {
+    securities: {
+        securities: Array<{
+            id: string;
+            entityId: string | null;
+            entityName: string | null;
+            sourceGraphId: string | null;
+            name: string;
+            securityType: string;
+            securitySubtype: string | null;
+            terms: any;
+            isActive: boolean;
+            authorizedShares: number | null;
+            outstandingShares: number | null;
+            createdAt: any;
+            updatedAt: any;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type GetInvestorSecurityQueryVariables = Exact<{
+    securityId: Scalars['String']['input'];
+}>;
+export type GetInvestorSecurityQuery = {
+    security: {
+        id: string;
+        entityId: string | null;
+        entityName: string | null;
+        sourceGraphId: string | null;
+        name: string;
+        securityType: string;
+        securitySubtype: string | null;
+        terms: any;
+        isActive: boolean;
+        authorizedShares: number | null;
+        outstandingShares: number | null;
+        createdAt: any;
+        updatedAt: any;
+    } | null;
+};
+export type GetLedgerAccountRollupsQueryVariables = Exact<{
+    mappingId: InputMaybe<Scalars['String']['input']>;
+    startDate: InputMaybe<Scalars['Date']['input']>;
+    endDate: InputMaybe<Scalars['Date']['input']>;
+}>;
+export type GetLedgerAccountRollupsQuery = {
+    accountRollups: {
+        mappingId: string;
+        mappingName: string;
+        totalMapped: number;
+        totalUnmapped: number;
+        groups: Array<{
+            reportingElementId: string;
+            reportingName: string;
+            reportingQname: string;
+            classification: string;
+            balanceType: string;
+            total: number;
+            accounts: Array<{
+                elementId: string;
+                accountName: string;
+                accountCode: string | null;
+                totalDebits: number;
+                totalCredits: number;
+                netBalance: number;
+            }>;
+        }>;
+    } | null;
+};
+export type GetLedgerAccountTreeQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLedgerAccountTreeQuery = {
+    accountTree: {
+        totalAccounts: number;
+        roots: Array<{
+            id: string;
+            code: string | null;
+            name: string;
+            classification: string;
+            accountType: string | null;
+            balanceType: string;
+            depth: number;
+            isActive: boolean;
+            children: Array<{
+                id: string;
+                code: string | null;
+                name: string;
+                classification: string;
+                accountType: string | null;
+                balanceType: string;
+                depth: number;
+                isActive: boolean;
+                children: Array<{
+                    id: string;
+                    code: string | null;
+                    name: string;
+                    classification: string;
+                    accountType: string | null;
+                    balanceType: string;
+                    depth: number;
+                    isActive: boolean;
+                    children: Array<{
+                        id: string;
+                        code: string | null;
+                        name: string;
+                        classification: string;
+                        accountType: string | null;
+                        balanceType: string;
+                        depth: number;
+                        isActive: boolean;
+                    }>;
+                }>;
+            }>;
+        }>;
+    } | null;
+};
+export type ListLedgerAccountsQueryVariables = Exact<{
+    classification: InputMaybe<Scalars['String']['input']>;
+    isActive: InputMaybe<Scalars['Boolean']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListLedgerAccountsQuery = {
+    accounts: {
+        accounts: Array<{
+            id: string;
+            code: string | null;
+            name: string;
+            description: string | null;
+            classification: string;
+            subClassification: string | null;
+            balanceType: string;
+            parentId: string | null;
+            depth: number;
+            currency: string;
+            isActive: boolean;
+            isPlaceholder: boolean;
+            accountType: string | null;
+            externalId: string | null;
+            externalSource: string | null;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type GetLedgerClosingBookStructuresQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLedgerClosingBookStructuresQuery = {
+    closingBookStructures: {
+        hasData: boolean;
+        categories: Array<{
+            label: string;
+            items: Array<{
+                id: string;
+                name: string;
+                itemType: string;
+                structureType: string | null;
+                reportId: string | null;
+                status: string | null;
+            }>;
+        }>;
+    } | null;
+};
+export type ListLedgerElementsQueryVariables = Exact<{
+    taxonomyId: InputMaybe<Scalars['String']['input']>;
+    source: InputMaybe<Scalars['String']['input']>;
+    classification: InputMaybe<Scalars['String']['input']>;
+    isAbstract: InputMaybe<Scalars['Boolean']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListLedgerElementsQuery = {
+    elements: {
+        elements: Array<{
+            id: string;
+            code: string | null;
+            name: string;
+            description: string | null;
+            qname: string | null;
+            namespace: string | null;
+            classification: string;
+            subClassification: string | null;
+            balanceType: string;
+            periodType: string;
+            isAbstract: boolean;
+            elementType: string;
+            source: string;
+            taxonomyId: string | null;
+            parentId: string | null;
+            depth: number;
+            isActive: boolean;
+            externalId: string | null;
+            externalSource: string | null;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type ListLedgerEntitiesQueryVariables = Exact<{
+    source: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ListLedgerEntitiesQuery = {
+    entities: Array<{
+        id: string;
+        name: string;
+        legalName: string | null;
+        ticker: string | null;
+        cik: string | null;
+        industry: string | null;
+        entityType: string | null;
+        status: string;
+        isParent: boolean;
+        parentEntityId: string | null;
+        source: string;
+        sourceGraphId: string | null;
+        connectionId: string | null;
+        createdAt: string | null;
+        updatedAt: string | null;
+    }>;
+};
+export type GetLedgerEntityQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLedgerEntityQuery = {
+    entity: {
+        id: string;
+        name: string;
+        legalName: string | null;
+        uri: string | null;
+        cik: string | null;
+        ticker: string | null;
+        exchange: string | null;
+        sic: string | null;
+        sicDescription: string | null;
+        category: string | null;
+        stateOfIncorporation: string | null;
+        fiscalYearEnd: string | null;
+        taxId: string | null;
+        lei: string | null;
+        industry: string | null;
+        entityType: string | null;
+        phone: string | null;
+        website: string | null;
+        status: string;
+        isParent: boolean;
+        parentEntityId: string | null;
+        source: string;
+        sourceId: string | null;
+        sourceGraphId: string | null;
+        connectionId: string | null;
+        addressLine1: string | null;
+        addressCity: string | null;
+        addressState: string | null;
+        addressPostalCode: string | null;
+        addressCountry: string | null;
+        createdAt: string | null;
+        updatedAt: string | null;
+    } | null;
+};
+export type GetLedgerFiscalCalendarQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLedgerFiscalCalendarQuery = {
+    fiscalCalendar: {
+        graphId: string;
+        fiscalYearStartMonth: number;
+        closedThrough: string | null;
+        closeTarget: string | null;
+        gapPeriods: number;
+        catchUpSequence: Array<string>;
+        closeableNow: boolean;
+        blockers: Array<string>;
+        lastCloseAt: any | null;
+        initializedAt: any | null;
+        lastSyncAt: any | null;
+        periods: Array<{
+            name: string;
+            startDate: any;
+            endDate: any;
+            status: string;
+            closedAt: any | null;
+        }>;
+    } | null;
+};
+export type GetLedgerMappedTrialBalanceQueryVariables = Exact<{
+    mappingId: Scalars['String']['input'];
+    startDate: InputMaybe<Scalars['Date']['input']>;
+    endDate: InputMaybe<Scalars['Date']['input']>;
+}>;
+export type GetLedgerMappedTrialBalanceQuery = {
+    mappedTrialBalance: {
+        mappingId: string;
+        rows: Array<{
+            reportingElementId: string;
+            qname: string;
+            reportingName: string;
+            classification: string | null;
+            balanceType: string | null;
+            totalDebits: number;
+            totalCredits: number;
+            netBalance: number;
+        }>;
+    } | null;
+};
+export type GetLedgerMappingQueryVariables = Exact<{
+    mappingId: Scalars['String']['input'];
+}>;
+export type GetLedgerMappingQuery = {
+    mapping: {
+        id: string;
+        name: string;
+        structureType: string;
+        taxonomyId: string;
+        totalAssociations: number;
+        associations: Array<{
+            id: string;
+            structureId: string;
+            fromElementId: string;
+            fromElementName: string | null;
+            fromElementQname: string | null;
+            toElementId: string;
+            toElementName: string | null;
+            toElementQname: string | null;
+            associationType: string;
+            orderValue: number | null;
+            weight: number | null;
+            confidence: number | null;
+            suggestedBy: string | null;
+            approvedBy: string | null;
+        }>;
+    } | null;
+};
+export type GetLedgerMappingCoverageQueryVariables = Exact<{
+    mappingId: Scalars['String']['input'];
+}>;
+export type GetLedgerMappingCoverageQuery = {
+    mappingCoverage: {
+        mappingId: string;
+        totalCoaElements: number;
+        mappedCount: number;
+        unmappedCount: number;
+        coveragePercent: number;
+        highConfidence: number;
+        mediumConfidence: number;
+        lowConfidence: number;
+    } | null;
+};
+export type ListLedgerMappingsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ListLedgerMappingsQuery = {
+    mappings: {
+        structures: Array<{
+            id: string;
+            name: string;
+            description: string | null;
+            structureType: string;
+            taxonomyId: string;
+            isActive: boolean;
+        }>;
+    } | null;
+};
+export type GetLedgerPeriodCloseStatusQueryVariables = Exact<{
+    periodStart: Scalars['Date']['input'];
+    periodEnd: Scalars['Date']['input'];
+}>;
+export type GetLedgerPeriodCloseStatusQuery = {
+    periodCloseStatus: {
+        fiscalPeriodStart: any;
+        fiscalPeriodEnd: any;
+        periodStatus: string;
+        totalDraft: number;
+        totalPosted: number;
+        schedules: Array<{
+            structureId: string;
+            structureName: string;
+            amount: number;
+            status: string;
+            entryId: string | null;
+            reversalEntryId: string | null;
+            reversalStatus: string | null;
+        }>;
+    } | null;
+};
+export type GetLedgerPeriodDraftsQueryVariables = Exact<{
+    period: Scalars['String']['input'];
+}>;
+export type GetLedgerPeriodDraftsQuery = {
+    periodDrafts: {
+        period: string;
+        periodStart: any;
+        periodEnd: any;
+        draftCount: number;
+        totalDebit: number;
+        totalCredit: number;
+        allBalanced: boolean;
+        drafts: Array<{
+            entryId: string;
+            postingDate: any;
+            type: string;
+            memo: string | null;
+            provenance: string | null;
+            sourceStructureId: string | null;
+            sourceStructureName: string | null;
+            totalDebit: number;
+            totalCredit: number;
+            balanced: boolean;
+            lineItems: Array<{
+                lineItemId: string;
+                elementId: string;
+                elementCode: string | null;
+                elementName: string;
+                debitAmount: number;
+                creditAmount: number;
+                description: string | null;
+            }>;
+        }>;
+    } | null;
+};
+export type GetLedgerPublishListQueryVariables = Exact<{
+    listId: Scalars['String']['input'];
+}>;
+export type GetLedgerPublishListQuery = {
+    publishList: {
+        id: string;
+        name: string;
+        description: string | null;
+        memberCount: number;
+        createdBy: string;
+        createdAt: any;
+        updatedAt: any;
+        members: Array<{
+            id: string;
+            targetGraphId: string;
+            targetGraphName: string | null;
+            targetOrgName: string | null;
+            addedBy: string;
+            addedAt: any;
+        }>;
+    } | null;
+};
+export type ListLedgerPublishListsQueryVariables = Exact<{
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListLedgerPublishListsQuery = {
+    publishLists: {
+        publishLists: Array<{
+            id: string;
+            name: string;
+            description: string | null;
+            memberCount: number;
+            createdBy: string;
+            createdAt: any;
+            updatedAt: any;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type GetLedgerReportQueryVariables = Exact<{
+    reportId: Scalars['String']['input'];
+}>;
+export type GetLedgerReportQuery = {
+    report: {
+        id: string;
+        name: string;
+        taxonomyId: string;
+        generationStatus: string;
+        periodType: string;
+        periodStart: any | null;
+        periodEnd: any | null;
+        comparative: boolean;
+        mappingId: string | null;
+        aiGenerated: boolean;
+        createdAt: any;
+        lastGenerated: any | null;
+        entityName: string | null;
+        sourceGraphId: string | null;
+        sourceReportId: string | null;
+        sharedAt: any | null;
+        periods: Array<{
+            start: any;
+            end: any;
+            label: string;
+        }> | null;
+        structures: Array<{
+            id: string;
+            name: string;
+            structureType: string;
+        }>;
+    } | null;
+};
+export type GetLedgerReportingTaxonomyQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLedgerReportingTaxonomyQuery = {
+    reportingTaxonomy: {
+        id: string;
+        name: string;
+        description: string | null;
+        taxonomyType: string;
+        version: string | null;
+        standard: string | null;
+        namespaceUri: string | null;
+        isShared: boolean;
+        isActive: boolean;
+        isLocked: boolean;
+        sourceTaxonomyId: string | null;
+        targetTaxonomyId: string | null;
+    } | null;
+};
+export type ListLedgerReportsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ListLedgerReportsQuery = {
+    reports: {
+        reports: Array<{
+            id: string;
+            name: string;
+            taxonomyId: string;
+            generationStatus: string;
+            periodType: string;
+            periodStart: any | null;
+            periodEnd: any | null;
+            comparative: boolean;
+            mappingId: string | null;
+            aiGenerated: boolean;
+            createdAt: any;
+            lastGenerated: any | null;
+            entityName: string | null;
+            sourceGraphId: string | null;
+            sourceReportId: string | null;
+            sharedAt: any | null;
+            periods: Array<{
+                start: any;
+                end: any;
+                label: string;
+            }> | null;
+            structures: Array<{
+                id: string;
+                name: string;
+                structureType: string;
+            }>;
+        }>;
+    } | null;
+};
+export type GetLedgerScheduleFactsQueryVariables = Exact<{
+    structureId: Scalars['String']['input'];
+    periodStart: InputMaybe<Scalars['Date']['input']>;
+    periodEnd: InputMaybe<Scalars['Date']['input']>;
+}>;
+export type GetLedgerScheduleFactsQuery = {
+    scheduleFacts: {
+        structureId: string;
+        facts: Array<{
+            elementId: string;
+            elementName: string;
+            value: number;
+            periodStart: any;
+            periodEnd: any;
+        }>;
+    } | null;
+};
+export type ListLedgerSchedulesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type ListLedgerSchedulesQuery = {
+    schedules: {
+        schedules: Array<{
+            structureId: string;
+            name: string;
+            taxonomyName: string;
+            entryTemplate: any | null;
+            scheduleMetadata: any | null;
+            totalPeriods: number;
+            periodsWithEntries: number;
+        }>;
+    } | null;
+};
+export type GetLedgerStatementQueryVariables = Exact<{
+    reportId: Scalars['String']['input'];
+    structureType: Scalars['String']['input'];
+}>;
+export type GetLedgerStatementQuery = {
+    statement: {
+        reportId: string;
+        structureId: string;
+        structureName: string;
+        structureType: string;
+        unmappedCount: number;
+        periods: Array<{
+            start: any;
+            end: any;
+            label: string;
+        }>;
+        rows: Array<{
+            elementId: string;
+            elementQname: string;
+            elementName: string;
+            classification: string;
+            values: Array<number | null>;
+            isSubtotal: boolean;
+            depth: number;
+        }>;
+        validation: {
+            passed: boolean;
+            checks: Array<string>;
+            failures: Array<string>;
+            warnings: Array<string>;
+        } | null;
+    } | null;
+};
+export type ListLedgerStructuresQueryVariables = Exact<{
+    taxonomyId: InputMaybe<Scalars['String']['input']>;
+    structureType: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ListLedgerStructuresQuery = {
+    structures: {
+        structures: Array<{
+            id: string;
+            name: string;
+            description: string | null;
+            structureType: string;
+            taxonomyId: string;
+            isActive: boolean;
+        }>;
+    } | null;
+};
+export type GetLedgerSummaryQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLedgerSummaryQuery = {
+    summary: {
+        graphId: string;
+        accountCount: number;
+        transactionCount: number;
+        entryCount: number;
+        lineItemCount: number;
+        earliestTransactionDate: any | null;
+        latestTransactionDate: any | null;
+        connectionCount: number;
+        lastSyncAt: any | null;
+    } | null;
+};
+export type ListLedgerTaxonomiesQueryVariables = Exact<{
+    taxonomyType: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ListLedgerTaxonomiesQuery = {
+    taxonomies: {
+        taxonomies: Array<{
+            id: string;
+            name: string;
+            description: string | null;
+            taxonomyType: string;
+            version: string | null;
+            standard: string | null;
+            namespaceUri: string | null;
+            isShared: boolean;
+            isActive: boolean;
+            isLocked: boolean;
+            sourceTaxonomyId: string | null;
+            targetTaxonomyId: string | null;
+        }>;
+    } | null;
+};
+export type GetLedgerTransactionQueryVariables = Exact<{
+    transactionId: Scalars['String']['input'];
+}>;
+export type GetLedgerTransactionQuery = {
+    transaction: {
+        id: string;
+        number: string | null;
+        type: string;
+        category: string | null;
+        amount: number;
+        currency: string;
+        date: any;
+        dueDate: any | null;
+        merchantName: string | null;
+        referenceNumber: string | null;
+        description: string | null;
+        source: string;
+        sourceId: string | null;
+        status: string;
+        postedAt: any | null;
+        entries: Array<{
+            id: string;
+            number: string | null;
+            type: string;
+            postingDate: any;
+            memo: string | null;
+            status: string;
+            postedAt: any | null;
+            lineItems: Array<{
+                id: string;
+                accountId: string;
+                accountName: string | null;
+                accountCode: string | null;
+                debitAmount: number;
+                creditAmount: number;
+                description: string | null;
+                lineOrder: number;
+            }>;
+        }>;
+    } | null;
+};
+export type ListLedgerTransactionsQueryVariables = Exact<{
+    type: InputMaybe<Scalars['String']['input']>;
+    startDate: InputMaybe<Scalars['Date']['input']>;
+    endDate: InputMaybe<Scalars['Date']['input']>;
+    limit?: Scalars['Int']['input'];
+    offset?: Scalars['Int']['input'];
+}>;
+export type ListLedgerTransactionsQuery = {
+    transactions: {
+        transactions: Array<{
+            id: string;
+            number: string | null;
+            type: string;
+            category: string | null;
+            amount: number;
+            currency: string;
+            date: any;
+            dueDate: any | null;
+            merchantName: string | null;
+            referenceNumber: string | null;
+            description: string | null;
+            source: string;
+            status: string;
+        }>;
+        pagination: {
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    } | null;
+};
+export type GetLedgerTrialBalanceQueryVariables = Exact<{
+    startDate: InputMaybe<Scalars['Date']['input']>;
+    endDate: InputMaybe<Scalars['Date']['input']>;
+}>;
+export type GetLedgerTrialBalanceQuery = {
+    trialBalance: {
+        totalDebits: number;
+        totalCredits: number;
+        rows: Array<{
+            accountId: string;
+            accountCode: string;
+            accountName: string;
+            classification: string;
+            accountType: string | null;
+            totalDebits: number;
+            totalCredits: number;
+            netBalance: number;
+        }>;
+    } | null;
+};
+export type ListLedgerUnmappedElementsQueryVariables = Exact<{
+    mappingId: InputMaybe<Scalars['String']['input']>;
+}>;
+export type ListLedgerUnmappedElementsQuery = {
+    unmappedElements: Array<{
+        id: string;
+        code: string | null;
+        name: string;
+        classification: string;
+        balanceType: string;
+        externalSource: string | null;
+        suggestedTargets: Array<{
+            elementId: string;
+            qname: string;
+            name: string;
+            confidence: number | null;
+        }>;
+    }>;
+};
+export declare const GetInvestorHoldingsDocument: DocumentNode<GetInvestorHoldingsQuery, GetInvestorHoldingsQueryVariables>;
+export declare const GetInvestorPortfolioDocument: DocumentNode<GetInvestorPortfolioQuery, GetInvestorPortfolioQueryVariables>;
+export declare const ListInvestorPortfoliosDocument: DocumentNode<ListInvestorPortfoliosQuery, ListInvestorPortfoliosQueryVariables>;
+export declare const GetInvestorPositionDocument: DocumentNode<GetInvestorPositionQuery, GetInvestorPositionQueryVariables>;
+export declare const ListInvestorPositionsDocument: DocumentNode<ListInvestorPositionsQuery, ListInvestorPositionsQueryVariables>;
+export declare const ListInvestorSecuritiesDocument: DocumentNode<ListInvestorSecuritiesQuery, ListInvestorSecuritiesQueryVariables>;
+export declare const GetInvestorSecurityDocument: DocumentNode<GetInvestorSecurityQuery, GetInvestorSecurityQueryVariables>;
+export declare const GetLedgerAccountRollupsDocument: DocumentNode<GetLedgerAccountRollupsQuery, GetLedgerAccountRollupsQueryVariables>;
+export declare const GetLedgerAccountTreeDocument: DocumentNode<GetLedgerAccountTreeQuery, GetLedgerAccountTreeQueryVariables>;
+export declare const ListLedgerAccountsDocument: DocumentNode<ListLedgerAccountsQuery, ListLedgerAccountsQueryVariables>;
+export declare const GetLedgerClosingBookStructuresDocument: DocumentNode<GetLedgerClosingBookStructuresQuery, GetLedgerClosingBookStructuresQueryVariables>;
+export declare const ListLedgerElementsDocument: DocumentNode<ListLedgerElementsQuery, ListLedgerElementsQueryVariables>;
+export declare const ListLedgerEntitiesDocument: DocumentNode<ListLedgerEntitiesQuery, ListLedgerEntitiesQueryVariables>;
+export declare const GetLedgerEntityDocument: DocumentNode<GetLedgerEntityQuery, GetLedgerEntityQueryVariables>;
+export declare const GetLedgerFiscalCalendarDocument: DocumentNode<GetLedgerFiscalCalendarQuery, GetLedgerFiscalCalendarQueryVariables>;
+export declare const GetLedgerMappedTrialBalanceDocument: DocumentNode<GetLedgerMappedTrialBalanceQuery, GetLedgerMappedTrialBalanceQueryVariables>;
+export declare const GetLedgerMappingDocument: DocumentNode<GetLedgerMappingQuery, GetLedgerMappingQueryVariables>;
+export declare const GetLedgerMappingCoverageDocument: DocumentNode<GetLedgerMappingCoverageQuery, GetLedgerMappingCoverageQueryVariables>;
+export declare const ListLedgerMappingsDocument: DocumentNode<ListLedgerMappingsQuery, ListLedgerMappingsQueryVariables>;
+export declare const GetLedgerPeriodCloseStatusDocument: DocumentNode<GetLedgerPeriodCloseStatusQuery, GetLedgerPeriodCloseStatusQueryVariables>;
+export declare const GetLedgerPeriodDraftsDocument: DocumentNode<GetLedgerPeriodDraftsQuery, GetLedgerPeriodDraftsQueryVariables>;
+export declare const GetLedgerPublishListDocument: DocumentNode<GetLedgerPublishListQuery, GetLedgerPublishListQueryVariables>;
+export declare const ListLedgerPublishListsDocument: DocumentNode<ListLedgerPublishListsQuery, ListLedgerPublishListsQueryVariables>;
+export declare const GetLedgerReportDocument: DocumentNode<GetLedgerReportQuery, GetLedgerReportQueryVariables>;
+export declare const GetLedgerReportingTaxonomyDocument: DocumentNode<GetLedgerReportingTaxonomyQuery, GetLedgerReportingTaxonomyQueryVariables>;
+export declare const ListLedgerReportsDocument: DocumentNode<ListLedgerReportsQuery, ListLedgerReportsQueryVariables>;
+export declare const GetLedgerScheduleFactsDocument: DocumentNode<GetLedgerScheduleFactsQuery, GetLedgerScheduleFactsQueryVariables>;
+export declare const ListLedgerSchedulesDocument: DocumentNode<ListLedgerSchedulesQuery, ListLedgerSchedulesQueryVariables>;
+export declare const GetLedgerStatementDocument: DocumentNode<GetLedgerStatementQuery, GetLedgerStatementQueryVariables>;
+export declare const ListLedgerStructuresDocument: DocumentNode<ListLedgerStructuresQuery, ListLedgerStructuresQueryVariables>;
+export declare const GetLedgerSummaryDocument: DocumentNode<GetLedgerSummaryQuery, GetLedgerSummaryQueryVariables>;
+export declare const ListLedgerTaxonomiesDocument: DocumentNode<ListLedgerTaxonomiesQuery, ListLedgerTaxonomiesQueryVariables>;
+export declare const GetLedgerTransactionDocument: DocumentNode<GetLedgerTransactionQuery, GetLedgerTransactionQueryVariables>;
+export declare const ListLedgerTransactionsDocument: DocumentNode<ListLedgerTransactionsQuery, ListLedgerTransactionsQueryVariables>;
+export declare const GetLedgerTrialBalanceDocument: DocumentNode<GetLedgerTrialBalanceQuery, GetLedgerTrialBalanceQueryVariables>;
+export declare const ListLedgerUnmappedElementsDocument: DocumentNode<ListLedgerUnmappedElementsQuery, ListLedgerUnmappedElementsQueryVariables>;