@robosystems/client 0.2.49 → 0.3.1

package/extensions/LedgerClient.d.ts

@@ -1,86 +1,54 @@
-import type { AccountListResponse, AccountRollupsResponse, AccountTreeResponse, ClosingBookStructuresResponse, LedgerSummaryResponse, LedgerTransactionDetailResponse, LedgerTransactionListResponse, MappingDetailResponse, TrialBalanceResponse } from '../types.gen';
-export interface LedgerEntity {
-    id: string;
-    name: string;
-    legalName: string | null;
-    entityType: string | null;
-    industry: string | null;
-    status: string | null;
-}
-export interface MappingInfo {
-    id: string;
-    name: string;
-    description: string | null;
-    structureType: string;
-    taxonomyId: string;
-    isActive: boolean;
-}
-export interface MappingCoverage {
-    totalCoaElements: number;
-    mappedCount: number;
-    unmappedCount: number;
-    coveragePercent: number;
-    highConfidence: number;
-    mediumConfidence: number;
-    lowConfidence: number;
-}
-export interface Structure {
-    id: string;
-    name: string;
-    structureType: string;
-}
-export interface Schedule {
-    structureId: string;
-    name: string;
-    taxonomyName: string;
-    entryTemplate: Record<string, unknown> | null;
-    scheduleMetadata: Record<string, unknown> | null;
-    totalPeriods: number;
-    periodsWithEntries: number;
-}
-export interface ScheduleCreated {
-    structureId: string;
-    name: string;
-    taxonomyId: string;
-    totalPeriods: number;
-    totalFacts: number;
-}
-export interface ScheduleFact {
-    elementId: string;
-    elementName: string;
-    value: number;
-    periodStart: string;
-    periodEnd: string;
-}
-export interface PeriodCloseItem {
-    structureId: string;
-    structureName: string;
-    amount: number;
-    status: string;
-    entryId: string | null;
+import type { AutoMapElementsOperation, CreateMappingAssociationOperation, CreateStructureRequest, CreateTaxonomyRequest, DeleteMappingAssociationOperation, OperationEnvelope, UpdateEntityRequest } from '../types.gen';
+import type { TokenProvider } from './graphql/client';
+import { type GetLedgerAccountRollupsQuery, type GetLedgerAccountTreeQuery, type GetLedgerClosingBookStructuresQuery, type GetLedgerEntityQuery, type GetLedgerFiscalCalendarQuery, type GetLedgerMappedTrialBalanceQuery, type GetLedgerMappingCoverageQuery, type GetLedgerMappingQuery, type GetLedgerPeriodCloseStatusQuery, type GetLedgerPeriodDraftsQuery, type GetLedgerReportingTaxonomyQuery, type GetLedgerScheduleFactsQuery, type GetLedgerSummaryQuery, type GetLedgerTransactionQuery, type GetLedgerTrialBalanceQuery, type ListLedgerAccountsQuery, type ListLedgerElementsQuery, type ListLedgerEntitiesQuery, type ListLedgerMappingsQuery, type ListLedgerSchedulesQuery, type ListLedgerStructuresQuery, type ListLedgerTaxonomiesQuery, type ListLedgerTransactionsQuery, type ListLedgerUnmappedElementsQuery } from './graphql/generated/graphql';
+export type LedgerEntity = NonNullable<GetLedgerEntityQuery['entity']>;
+export type LedgerEntitySummary = ListLedgerEntitiesQuery['entities'][number];
+export type LedgerSummary = NonNullable<GetLedgerSummaryQuery['summary']>;
+export type LedgerAccountList = NonNullable<ListLedgerAccountsQuery['accounts']>;
+export type LedgerAccount = LedgerAccountList['accounts'][number];
+export type LedgerAccountTree = NonNullable<GetLedgerAccountTreeQuery['accountTree']>;
+export type LedgerAccountRollups = NonNullable<GetLedgerAccountRollupsQuery['accountRollups']>;
+export type LedgerTrialBalance = NonNullable<GetLedgerTrialBalanceQuery['trialBalance']>;
+export type LedgerMappedTrialBalance = NonNullable<GetLedgerMappedTrialBalanceQuery['mappedTrialBalance']>;
+export type LedgerTransactionList = NonNullable<ListLedgerTransactionsQuery['transactions']>;
+export type LedgerTransactionListItem = LedgerTransactionList['transactions'][number];
+export type LedgerTransaction = NonNullable<GetLedgerTransactionQuery['transaction']>;
+export type LedgerReportingTaxonomy = NonNullable<GetLedgerReportingTaxonomyQuery['reportingTaxonomy']>;
+export type LedgerTaxonomyList = NonNullable<ListLedgerTaxonomiesQuery['taxonomies']>;
+export type LedgerTaxonomy = LedgerTaxonomyList['taxonomies'][number];
+export type LedgerElementList = NonNullable<ListLedgerElementsQuery['elements']>;
+export type LedgerElement = LedgerElementList['elements'][number];
+export type LedgerUnmappedElement = ListLedgerUnmappedElementsQuery['unmappedElements'][number];
+export type LedgerStructureList = NonNullable<ListLedgerStructuresQuery['structures']>;
+export type LedgerStructure = LedgerStructureList['structures'][number];
+export type LedgerMappingList = NonNullable<ListLedgerMappingsQuery['mappings']>;
+export type LedgerMappingInfo = LedgerMappingList['structures'][number];
+export type LedgerMapping = NonNullable<GetLedgerMappingQuery['mapping']>;
+export type LedgerMappingCoverage = NonNullable<GetLedgerMappingCoverageQuery['mappingCoverage']>;
+export type LedgerScheduleList = NonNullable<ListLedgerSchedulesQuery['schedules']>;
+export type LedgerSchedule = LedgerScheduleList['schedules'][number];
+export type LedgerScheduleFacts = NonNullable<GetLedgerScheduleFactsQuery['scheduleFacts']>;
+export type LedgerScheduleFact = LedgerScheduleFacts['facts'][number];
+export type LedgerPeriodCloseStatus = NonNullable<GetLedgerPeriodCloseStatusQuery['periodCloseStatus']>;
+export type LedgerPeriodCloseItem = LedgerPeriodCloseStatus['schedules'][number];
+export type LedgerPeriodDrafts = NonNullable<GetLedgerPeriodDraftsQuery['periodDrafts']>;
+export type LedgerDraftEntry = LedgerPeriodDrafts['drafts'][number];
+export type LedgerDraftLineItem = LedgerDraftEntry['lineItems'][number];
+export type LedgerClosingBookStructures = NonNullable<GetLedgerClosingBookStructuresQuery['closingBookStructures']>;
+export type LedgerFiscalCalendar = NonNullable<GetLedgerFiscalCalendarQuery['fiscalCalendar']>;
+export type LedgerFiscalPeriod = LedgerFiscalCalendar['periods'][number];
+export interface InitializeLedgerResult {
+    fiscalCalendar: LedgerFiscalCalendar;
+    periodsCreated: number;
+    warnings: string[];
 }
-export interface PeriodCloseStatus {
-    fiscalPeriodStart: string;
-    fiscalPeriodEnd: string;
-    periodStatus: string;
-    schedules: PeriodCloseItem[];
-    totalDraft: number;
-    totalPosted: number;
+export interface ClosePeriodResult {
+    period: string;
+    entriesPosted: number;
+    targetAutoAdvanced: boolean;
+    fiscalCalendar: LedgerFiscalCalendar;
 }
-/**
- * Outcome of an idempotent `createClosingEntry` call.
- *
- * - `created`     — no prior draft, new draft created
- * - `unchanged`   — prior draft matches current schedule fact, no-op
- * - `regenerated` — prior draft was stale, replaced with a fresh one
- * - `removed`     — prior draft existed but schedule no longer covers this period
- * - `skipped`     — no prior draft and no in-scope fact; nothing to do
- */
 export type ClosingEntryOutcome = 'created' | 'unchanged' | 'regenerated' | 'removed' | 'skipped';
-/**
- * Result of an idempotent closing-entry call. `entry_id`, `amount`, and
- * related fields are null for `removed` and `skipped` outcomes.
- */
 export interface ClosingEntry {
     outcome: ClosingEntryOutcome;
     entryId: string | null;
@@ -92,28 +60,20 @@ export interface ClosingEntry {
     amount: number | null;
     reason: string | null;
 }
-export type LedgerEntryType = 'standard' | 'adjusting' | 'closing' | 'reversing';
-export interface FiscalPeriodSummary {
+export interface ScheduleCreated {
+    structureId: string;
     name: string;
-    startDate: string;
-    endDate: string;
-    status: string;
-    closedAt: string | null;
+    taxonomyId: string;
+    totalPeriods: number;
+    totalFacts: number;
 }
-export interface FiscalCalendarState {
-    graphId: string;
-    fiscalYearStartMonth: number;
-    closedThrough: string | null;
-    closeTarget: string | null;
-    gapPeriods: number;
-    catchUpSequence: string[];
-    closeableNow: boolean;
-    blockers: string[];
-    lastCloseAt: string | null;
-    initializedAt: string | null;
-    lastSyncAt: string | null;
-    periods: FiscalPeriodSummary[];
+export interface TruncateScheduleResult {
+    structureId: string;
+    newEndDate: string;
+    factsDeleted: number;
+    reason: string;
 }
+export type LedgerEntryType = 'standard' | 'adjusting' | 'closing' | 'reversing';
 export interface InitializeLedgerOptions {
     closedThrough?: string | null;
     fiscalYearStartMonth?: number;
@@ -121,53 +81,10 @@ export interface InitializeLedgerOptions {
     autoSeedSchedules?: boolean;
     note?: string | null;
 }
-export interface InitializeLedgerResult {
-    fiscalCalendar: FiscalCalendarState;
-    periodsCreated: number;
-    warnings: string[];
-}
 export interface ClosePeriodOptions {
     note?: string | null;
     allowStaleSync?: boolean;
 }
-export interface ClosePeriodResult {
-    period: string;
-    entriesPosted: number;
-    targetAutoAdvanced: boolean;
-    fiscalCalendar: FiscalCalendarState;
-}
-export interface DraftLineItemView {
-    lineItemId: string;
-    elementId: string;
-    elementCode: string | null;
-    elementName: string;
-    debitAmount: number;
-    creditAmount: number;
-    description: string | null;
-}
-export interface DraftEntryView {
-    entryId: string;
-    postingDate: string;
-    type: string;
-    memo: string | null;
-    provenance: string | null;
-    sourceStructureId: string | null;
-    sourceStructureName: string | null;
-    lineItems: DraftLineItemView[];
-    totalDebit: number;
-    totalCredit: number;
-    balanced: boolean;
-}
-export interface PeriodDraftsView {
-    period: string;
-    periodStart: string;
-    periodEnd: string;
-    draftCount: number;
-    totalDebit: number;
-    totalCredit: number;
-    allBalanced: boolean;
-    drafts: DraftEntryView[];
-}
 export interface ManualClosingLineItem {
     elementId: string;
     debitAmount?: number;
@@ -184,12 +101,6 @@ export interface TruncateScheduleOptions {
     newEndDate: string;
     reason: string;
 }
-export interface TruncateScheduleResult {
-    structureId: string;
-    newEndDate: string;
-    factsDeleted: number;
-    reason: string;
-}
 export interface CreateScheduleOptions {
     name: string;
     elementIds: string[];
@@ -211,69 +122,87 @@ export interface CreateScheduleOptions {
         assetElementId?: string;
     };
 }
-export declare class LedgerClient {
-    private config;
-    constructor(config: {
-        baseUrl: string;
-        credentials?: 'include' | 'same-origin' | 'omit';
-        headers?: Record<string, string>;
-        token?: string;
-    });
+interface LedgerClientConfig {
+    baseUrl: string;
+    credentials?: 'include' | 'same-origin' | 'omit';
+    headers?: Record<string, string>;
+    /** Static credential — use `tokenProvider` instead if the JWT rotates. */
+    token?: string;
     /**
-     * Get the entity (company/organization) for this graph.
+     * Dynamic credential callback. When set, invoked on every GraphQL
+     * request so refreshes flow through automatically.
      */
-    getEntity(graphId: string): Promise<LedgerEntity | null>;
+    tokenProvider?: TokenProvider;
+}
+export declare class LedgerClient {
+    private config;
     /**
-     * List accounts (flat).
+     * Per-graph GraphQL client cache. The first call for a given graph
+     * creates a `GraphQLClient` bound to `/extensions/{graph_id}/graphql`;
+     * subsequent calls reuse it.
      */
-    listAccounts(graphId: string): Promise<AccountListResponse>;
+    private gql;
+    constructor(config: LedgerClientConfig);
     /**
-     * Get the account tree (hierarchical).
+     * Get the entity (company/organization) for this graph.
+     * Returns null when the ledger has no entity yet.
      */
-    getAccountTree(graphId: string): Promise<AccountTreeResponse>;
+    getEntity(graphId: string): Promise<LedgerEntity | null>;
+    /** List all entities for this graph, optionally filtered by source system. */
+    listEntities(graphId: string, options?: {
+        source?: string;
+    }): Promise<LedgerEntitySummary[]>;
     /**
-     * List transactions with optional date filters.
+     * Update the entity for this graph. Only non-null fields are applied.
+     * Returns the updated entity.
      */
+    updateEntity(graphId: string, updates: UpdateEntityRequest): Promise<LedgerEntity>;
+    /** Ledger rollup counts + QB sync metadata. */
+    getSummary(graphId: string): Promise<LedgerSummary | null>;
+    /** List CoA accounts with optional filters and pagination. */
+    listAccounts(graphId: string, options?: {
+        classification?: string;
+        isActive?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<LedgerAccountList | null>;
+    /** Hierarchical Chart of Accounts (up to 4 levels deep). */
+    getAccountTree(graphId: string): Promise<LedgerAccountTree | null>;
+    /** Accounts rolled up to reporting concepts via a mapping structure. */
+    getAccountRollups(graphId: string, options?: {
+        mappingId?: string;
+        startDate?: string;
+        endDate?: string;
+    }): Promise<LedgerAccountRollups | null>;
+    /** List transactions with optional type + date filters and pagination. */
     listTransactions(graphId: string, options?: {
+        type?: string;
         startDate?: string;
         endDate?: string;
         limit?: number;
         offset?: number;
-    }): Promise<LedgerTransactionListResponse>;
-    /**
-     * Get transaction detail with entries and line items.
-     */
-    getTransaction(graphId: string, transactionId: string): Promise<LedgerTransactionDetailResponse>;
-    /**
-     * Get trial balance (CoA-level debits/credits).
-     */
+    }): Promise<LedgerTransactionList | null>;
+    /** Get transaction detail with entries + line items. */
+    getTransaction(graphId: string, transactionId: string): Promise<LedgerTransaction | null>;
+    /** Trial balance by raw CoA account. */
     getTrialBalance(graphId: string, options?: {
         startDate?: string;
         endDate?: string;
-    }): Promise<TrialBalanceResponse>;
-    /**
-     * Get mapped trial balance (CoA rolled up to GAAP concepts).
-     */
-    getMappedTrialBalance(graphId: string, options?: {
-        mappingId?: string;
+    }): Promise<LedgerTrialBalance | null>;
+    /** Trial balance rolled up to GAAP reporting concepts via a mapping. */
+    getMappedTrialBalance(graphId: string, mappingId: string, options?: {
         startDate?: string;
         endDate?: string;
-    }): Promise<unknown>;
-    /**
-     * Get ledger summary (account count, transaction count, date range).
-     */
-    getSummary(graphId: string): Promise<LedgerSummaryResponse>;
-    /**
-     * Get the reporting taxonomy (US GAAP seed).
-     */
-    getReportingTaxonomy(graphId: string): Promise<unknown>;
-    /**
-     * List reporting structures (IS, BS, CF) for a taxonomy.
-     */
-    listStructures(graphId: string, taxonomyId?: string): Promise<Structure[]>;
-    /**
-     * List elements (CoA accounts, GAAP concepts, etc.).
-     */
+    }): Promise<LedgerMappedTrialBalance | null>;
+    /** Get the locked US GAAP reporting taxonomy for this graph. */
+    getReportingTaxonomy(graphId: string): Promise<LedgerReportingTaxonomy | null>;
+    /** List active taxonomies with optional type filter. */
+    listTaxonomies(graphId: string, options?: {
+        taxonomyType?: string;
+    }): Promise<LedgerTaxonomy[]>;
+    /** Create a new taxonomy (used for CoA + mapping taxonomies). */
+    createTaxonomy(graphId: string, body: CreateTaxonomyRequest): Promise<Record<string, unknown>>;
+    /** List elements (CoA accounts, GAAP concepts, etc.) with filters. */
     listElements(graphId: string, options?: {
         taxonomyId?: string;
         source?: string;
@@ -281,136 +210,88 @@ export declare class LedgerClient {
         isAbstract?: boolean;
         limit?: number;
         offset?: number;
-    }): Promise<unknown>;
-    /**
-     * Create a new CoA→GAAP mapping structure.
-     * Returns the created mapping info.
-     */
-    createMappingStructure(graphId: string, options?: {
-        name?: string;
-        description?: string;
+    }): Promise<LedgerElementList | null>;
+    /** CoA elements not yet mapped to a reporting concept. */
+    listUnmappedElements(graphId: string, options?: {
+        mappingId?: string;
+    }): Promise<LedgerUnmappedElement[]>;
+    /** List reporting structures (IS, BS, CF, schedules) with optional filters. */
+    listStructures(graphId: string, options?: {
         taxonomyId?: string;
-    }): Promise<MappingInfo>;
-    /**
-     * List available CoA→GAAP mapping structures.
-     */
-    listMappings(graphId: string): Promise<MappingInfo[]>;
-    /**
-     * Get mapping detail — all associations with element names.
-     */
-    getMappingDetail(graphId: string, mappingId: string): Promise<MappingDetailResponse>;
-    /**
-     * Get mapping coverage — how many CoA elements are mapped.
-     */
-    getMappingCoverage(graphId: string, mappingId: string): Promise<MappingCoverage>;
-    /**
-     * Create a manual mapping association (CoA element → GAAP element).
-     */
-    createMapping(graphId: string, mappingId: string, fromElementId: string, toElementId: string, confidence?: number): Promise<void>;
-    /**
-     * Delete a mapping association.
-     */
-    deleteMapping(graphId: string, mappingId: string, associationId: string): Promise<void>;
-    /**
-     * Trigger AI auto-mapping (MappingAgent).
-     * Returns immediately — the agent runs in the background.
-     */
-    autoMap(graphId: string, mappingId: string): Promise<{
-        operationId?: string;
+        structureType?: string;
+    }): Promise<LedgerStructure[]>;
+    /**
+     * Create a new structure. Most common use is a CoA→reporting mapping
+     * structure; also used for custom statement + schedule structures.
+     */
+    createStructure(graphId: string, body: CreateStructureRequest): Promise<LedgerMappingInfo>;
+    /** List active CoA→reporting mapping structures. */
+    listMappings(graphId: string): Promise<LedgerMappingInfo[]>;
+    /** Get a mapping structure with all its associations. */
+    getMapping(graphId: string, mappingId: string): Promise<LedgerMapping | null>;
+    /** Mapping coverage stats — how many CoA elements are mapped. */
+    getMappingCoverage(graphId: string, mappingId: string): Promise<LedgerMappingCoverage | null>;
+    /** Create a manual mapping association between two elements. */
+    createMappingAssociation(graphId: string, body: CreateMappingAssociationOperation): Promise<Record<string, unknown>>;
+    /** Delete a mapping association. */
+    deleteMappingAssociation(graphId: string, body: DeleteMappingAssociationOperation): Promise<{
+        deleted: boolean;
     }>;
     /**
-     * Create a schedule with pre-generated monthly facts.
+     * Trigger the AI MappingAgent. Returns the operation id — async; the
+     * agent runs in the background. Consumers can subscribe to progress
+     * via `/v1/operations/{operationId}/stream`.
      */
+    autoMapElements(graphId: string, body: AutoMapElementsOperation): Promise<{
+        operationId: string;
+        status: OperationEnvelope['status'];
+    }>;
+    /** List all schedule structures with metadata. */
+    listSchedules(graphId: string): Promise<LedgerSchedule[]>;
+    /** Schedule facts optionally filtered by period window. */
+    getScheduleFacts(graphId: string, structureId: string, options?: {
+        periodStart?: string;
+        periodEnd?: string;
+    }): Promise<LedgerScheduleFact[]>;
+    /** Create a new schedule with pre-generated monthly facts. */
     createSchedule(graphId: string, options: CreateScheduleOptions): Promise<ScheduleCreated>;
+    /** Truncate a schedule — end it early at `newEndDate`. */
+    truncateSchedule(graphId: string, structureId: string, options: TruncateScheduleOptions): Promise<TruncateScheduleResult>;
+    /** Close status for all schedules in a fiscal period. */
+    getPeriodCloseStatus(graphId: string, periodStart: string, periodEnd: string): Promise<LedgerPeriodCloseStatus | null>;
+    /** All draft entries in a period, fully expanded for review pre-close. */
+    listPeriodDrafts(graphId: string, period: string): Promise<LedgerPeriodDrafts | null>;
     /**
-     * List all schedules for a graph.
-     */
-    listSchedules(graphId: string): Promise<Schedule[]>;
-    /**
-     * Get facts for a schedule, optionally filtered by period.
-     */
-    getScheduleFacts(graphId: string, structureId: string, periodStart?: string, periodEnd?: string): Promise<ScheduleFact[]>;
-    /**
-     * Get close status for all schedules in a fiscal period.
-     */
-    getPeriodCloseStatus(graphId: string, periodStart: string, periodEnd: string): Promise<PeriodCloseStatus>;
-    /**
-     * Idempotently create (or refresh) a draft closing entry from a schedule's
-     * facts for a period. The `outcome` field describes what actually happened:
-     *
-     * - `created`     — new draft
-     * - `unchanged`   — existing draft still matches the schedule; no-op
-     * - `regenerated` — existing draft was stale; replaced
-     * - `removed`     — schedule no longer covers this period; stale draft deleted
-     * - `skipped`     — no existing draft and no in-scope fact; nothing to do
+     * Idempotently create (or refresh) a draft closing entry from a
+     * schedule for a period. See `ClosingEntryOutcome` for semantics.
      */
     createClosingEntry(graphId: string, structureId: string, postingDate: string, periodStart: string, periodEnd: string, memo?: string): Promise<ClosingEntry>;
     /**
-     * Get all closing book structure categories for the sidebar.
-     * Returns statements, account rollups, schedules, trial balance,
-     * and period close grouped into categories.
-     */
-    getClosingBookStructures(graphId: string): Promise<ClosingBookStructuresResponse>;
-    /**
-     * Get account rollups — CoA accounts grouped by reporting element with balances.
-     * Shows how company-specific accounts roll up to standardized reporting lines.
-     */
-    getAccountRollups(graphId: string, options?: {
-        mappingId?: string;
-        startDate?: string;
-        endDate?: string;
-    }): Promise<AccountRollupsResponse>;
-    /**
-     * Initialize the fiscal calendar for a graph. Creates FiscalPeriod rows
-     * for the data window, sets `closed_through` / `close_target`, and emits
-     * an `initialized` audit event. Fails with 409 if already initialized.
+     * Create a manual balanced closing entry (not tied to a schedule).
+     * Used for disposals, adjustments, and one-off closing events.
      */
+    createManualClosingEntry(graphId: string, options: CreateManualClosingEntryOptions): Promise<ClosingEntry>;
+    /** Grouped closing book structures for the close-screen sidebar. */
+    getClosingBookStructures(graphId: string): Promise<LedgerClosingBookStructures | null>;
+    /** Current fiscal calendar state — pointers, gap, closeable status. */
+    getFiscalCalendar(graphId: string): Promise<LedgerFiscalCalendar | null>;
+    /** One-time ledger initialization — seed fiscal calendar + periods. */
     initializeLedger(graphId: string, options?: InitializeLedgerOptions): Promise<InitializeLedgerResult>;
-    /**
-     * Get the current fiscal calendar state — pointers, gap, closeable status.
-     */
-    getFiscalCalendar(graphId: string): Promise<FiscalCalendarState>;
-    /**
-     * Set the close target for a graph. Validates that the target is not in
-     * the future and not before `closed_through`.
-     */
-    setCloseTarget(graphId: string, period: string, note?: string | null): Promise<FiscalCalendarState>;
-    /**
-     * Close a fiscal period — the final commit action.
-     *
-     * Validates closeable gates, transitions all draft entries in the period
-     * to `posted`, marks the FiscalPeriod closed, and advances `closed_through`
-     * (auto-advancing `close_target` when reached).
-     */
+    /** Set the user-controlled close target (YYYY-MM). */
+    setCloseTarget(graphId: string, period: string, note?: string | null): Promise<LedgerFiscalCalendar>;
+    /** Close a fiscal period — the final commit action. */
     closePeriod(graphId: string, period: string, options?: ClosePeriodOptions): Promise<ClosePeriodResult>;
+    /** Reopen a closed fiscal period. Requires a reason for the audit log. */
+    reopenPeriod(graphId: string, period: string, reason: string, note?: string | null): Promise<LedgerFiscalCalendar>;
     /**
-     * Reopen a closed fiscal period. Requires a non-empty `reason` for the
-     * audit log. Posted entries stay posted; the period transitions to
-     * `closing` so the user can post adjustments and re-close.
-     */
-    reopenPeriod(graphId: string, period: string, reason: string, note?: string | null): Promise<FiscalCalendarState>;
-    /**
-     * List all draft entries in a fiscal period for review before close.
-     * Fully expanded with line items, element metadata, and per-entry balance.
-     *
-     * Pure read — call repeatedly without side effects.
+     * Run a typed GraphQL query against the per-graph endpoint and
+     * translate ClientError into a readable facade error.
      */
-    listPeriodDrafts(graphId: string, period: string): Promise<PeriodDraftsView>;
+    private gqlQuery;
     /**
-     * Truncate a schedule — end it early by deleting facts with
-     * `period_start > new_end_date`, along with any stale draft entries they
-     * produced. Historical posted facts are preserved.
-     *
-     * `new_end_date` must be a month-end date (service enforces this).
+     * Await an SDK-generated `opXxx(...)` call, throw a readable error on
+     * non-2xx, and return the `OperationEnvelope` on success.
      */
-    truncateSchedule(graphId: string, structureId: string, options: TruncateScheduleOptions): Promise<TruncateScheduleResult>;
-    /**
-     * Create a manual draft closing entry with arbitrary balanced line items.
-     * Not tied to a schedule — used for disposals, adjustments, and other
-     * one-off closing events.
-     *
-     * Line items must sum to balanced debits/credits. Rejects entries
-     * targeting an already-closed period.
-     */
-    createManualClosingEntry(graphId: string, options: CreateManualClosingEntryOptions): Promise<ClosingEntry>;
+    private callOperation;
 }
+export {};