@robosystems/client 0.2.43 → 0.2.45

package/sdk-extensions/LedgerClient.d.ts

@@ -29,6 +29,74 @@ export interface Structure {
     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;
+}
+export interface PeriodCloseStatus {
+    fiscalPeriodStart: string;
+    fiscalPeriodEnd: string;
+    periodStatus: string;
+    schedules: PeriodCloseItem[];
+    totalDraft: number;
+    totalPosted: number;
+}
+export interface ClosingEntry {
+    entryId: string;
+    status: string;
+    postingDate: string;
+    memo: string;
+    debitElementId: string;
+    creditElementId: string;
+    amount: number;
+}
+export interface CreateScheduleOptions {
+    name: string;
+    elementIds: string[];
+    periodStart: string;
+    periodEnd: string;
+    monthlyAmount: number;
+    entryTemplate: {
+        debitElementId: string;
+        creditElementId: string;
+        entryType?: string;
+        memoTemplate?: string;
+    };
+    taxonomyId?: string;
+    scheduleMetadata?: {
+        method?: string;
+        originalAmount?: number;
+        residualValue?: number;
+        usefulLifeMonths?: number;
+        assetElementId?: string;
+    };
+}
 export declare class LedgerClient {
     private config;
     constructor(config: {
@@ -136,4 +204,24 @@ export declare class LedgerClient {
     autoMap(graphId: string, mappingId: string): Promise<{
         operationId?: string;
     }>;
+    /**
+     * Create a schedule with pre-generated monthly facts.
+     */
+    createSchedule(graphId: string, options: CreateScheduleOptions): Promise<ScheduleCreated>;
+    /**
+     * 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>;
+    /**
+     * Create a draft closing entry from a schedule's facts for a period.
+     */
+    createClosingEntry(graphId: string, structureId: string, postingDate: string, periodStart: string, periodEnd: string, memo?: string): Promise<ClosingEntry>;
 }

package/sdk-extensions/LedgerClient.js

@@ -316,5 +316,148 @@ class LedgerClient {
             operationId: data?.operation_id,
         };
     }
+    // ── Schedules ──────────────────────────────────────────────────────
+    /**
+     * Create a schedule with pre-generated monthly facts.
+     */
+    async createSchedule(graphId, options) {
+        const body = {
+            name: options.name,
+            element_ids: options.elementIds,
+            period_start: options.periodStart,
+            period_end: options.periodEnd,
+            monthly_amount: options.monthlyAmount,
+            entry_template: {
+                debit_element_id: options.entryTemplate.debitElementId,
+                credit_element_id: options.entryTemplate.creditElementId,
+                entry_type: options.entryTemplate.entryType,
+                memo_template: options.entryTemplate.memoTemplate,
+            },
+            taxonomy_id: options.taxonomyId,
+            schedule_metadata: options.scheduleMetadata
+                ? {
+                    method: options.scheduleMetadata.method,
+                    original_amount: options.scheduleMetadata.originalAmount,
+                    residual_value: options.scheduleMetadata.residualValue,
+                    useful_life_months: options.scheduleMetadata.usefulLifeMonths,
+                    asset_element_id: options.scheduleMetadata.assetElementId,
+                }
+                : undefined,
+        };
+        const response = await (0, sdk_gen_1.createSchedule)({
+            path: { graph_id: graphId },
+            body,
+        });
+        if (response.error) {
+            throw new Error(`Create schedule failed: ${JSON.stringify(response.error)}`);
+        }
+        const data = response.data;
+        return {
+            structureId: data.structure_id,
+            name: data.name,
+            taxonomyId: data.taxonomy_id,
+            totalPeriods: data.total_periods,
+            totalFacts: data.total_facts,
+        };
+    }
+    /**
+     * List all schedules for a graph.
+     */
+    async listSchedules(graphId) {
+        const response = await (0, sdk_gen_1.listSchedules)({
+            path: { graph_id: graphId },
+        });
+        if (response.error) {
+            throw new Error(`List schedules failed: ${JSON.stringify(response.error)}`);
+        }
+        const data = response.data;
+        return (data.schedules ?? []).map((s) => ({
+            structureId: s.structure_id,
+            name: s.name,
+            taxonomyName: s.taxonomy_name,
+            entryTemplate: s.entry_template ?? null,
+            scheduleMetadata: s.schedule_metadata ?? null,
+            totalPeriods: s.total_periods,
+            periodsWithEntries: s.periods_with_entries,
+        }));
+    }
+    /**
+     * Get facts for a schedule, optionally filtered by period.
+     */
+    async getScheduleFacts(graphId, structureId, periodStart, periodEnd) {
+        const response = await (0, sdk_gen_1.getScheduleFacts)({
+            path: { graph_id: graphId, structure_id: structureId },
+            query: {
+                period_start: periodStart ?? null,
+                period_end: periodEnd ?? null,
+            },
+        });
+        if (response.error) {
+            throw new Error(`Get schedule facts failed: ${JSON.stringify(response.error)}`);
+        }
+        const data = response.data;
+        return (data.facts ?? []).map((f) => ({
+            elementId: f.element_id,
+            elementName: f.element_name,
+            value: f.value,
+            periodStart: f.period_start,
+            periodEnd: f.period_end,
+        }));
+    }
+    /**
+     * Get close status for all schedules in a fiscal period.
+     */
+    async getPeriodCloseStatus(graphId, periodStart, periodEnd) {
+        const response = await (0, sdk_gen_1.getPeriodCloseStatus)({
+            path: { graph_id: graphId },
+            query: { period_start: periodStart, period_end: periodEnd },
+        });
+        if (response.error) {
+            throw new Error(`Get period close status failed: ${JSON.stringify(response.error)}`);
+        }
+        const data = response.data;
+        return {
+            fiscalPeriodStart: data.fiscal_period_start,
+            fiscalPeriodEnd: data.fiscal_period_end,
+            periodStatus: data.period_status,
+            schedules: (data.schedules ?? []).map((s) => ({
+                structureId: s.structure_id,
+                structureName: s.structure_name,
+                amount: s.amount,
+                status: s.status,
+                entryId: s.entry_id ?? null,
+            })),
+            totalDraft: data.total_draft,
+            totalPosted: data.total_posted,
+        };
+    }
+    /**
+     * Create a draft closing entry from a schedule's facts for a period.
+     */
+    async createClosingEntry(graphId, structureId, postingDate, periodStart, periodEnd, memo) {
+        const body = {
+            posting_date: postingDate,
+            period_start: periodStart,
+            period_end: periodEnd,
+            memo: memo ?? undefined,
+        };
+        const response = await (0, sdk_gen_1.createClosingEntry)({
+            path: { graph_id: graphId, structure_id: structureId },
+            body,
+        });
+        if (response.error) {
+            throw new Error(`Create closing entry failed: ${JSON.stringify(response.error)}`);
+        }
+        const data = response.data;
+        return {
+            entryId: data.entry_id,
+            status: data.status,
+            postingDate: data.posting_date,
+            memo: data.memo,
+            debitElementId: data.debit_element_id,
+            creditElementId: data.credit_element_id,
+            amount: data.amount,
+        };
+    }
 }
 exports.LedgerClient = LedgerClient;

package/sdk-extensions/LedgerClient.ts

@@ -10,7 +10,9 @@
 
 import {
   autoMapElements,
+  createClosingEntry,
   createMappingAssociation,
+  createSchedule,
   createStructure,
   deleteMappingAssociation,
   getLedgerAccountTree,
@@ -21,21 +23,34 @@ import {
   getMappedTrialBalance,
   getMappingCoverage,
   getMappingDetail,
+  getPeriodCloseStatus,
   getReportingTaxonomy,
+  getScheduleFacts,
   listElements,
   listLedgerAccounts,
   listLedgerTransactions,
   listMappings,
+  listSchedules,
   listStructures,
 } from '../sdk/sdk.gen'
 import type {
   AccountListResponse,
   AccountTreeResponse,
+  ClosingEntryResponse,
+  CreateClosingEntryRequest,
+  CreateScheduleRequest,
   LedgerSummaryResponse,
   LedgerTransactionDetailResponse,
   LedgerTransactionListResponse,
   MappingCoverageResponse,
   MappingDetailResponse,
+  PeriodCloseItemResponse,
+  PeriodCloseStatusResponse,
+  ScheduleCreatedResponse,
+  ScheduleFactResponse,
+  ScheduleFactsResponse,
+  ScheduleListResponse,
+  ScheduleSummaryResponse,
   TrialBalanceResponse,
 } from '../sdk/types.gen'
 
@@ -75,6 +90,81 @@ export interface Structure {
   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
+}
+
+export interface PeriodCloseStatus {
+  fiscalPeriodStart: string
+  fiscalPeriodEnd: string
+  periodStatus: string
+  schedules: PeriodCloseItem[]
+  totalDraft: number
+  totalPosted: number
+}
+
+export interface ClosingEntry {
+  entryId: string
+  status: string
+  postingDate: string
+  memo: string
+  debitElementId: string
+  creditElementId: string
+  amount: number
+}
+
+export interface CreateScheduleOptions {
+  name: string
+  elementIds: string[]
+  periodStart: string
+  periodEnd: string
+  monthlyAmount: number
+  entryTemplate: {
+    debitElementId: string
+    creditElementId: string
+    entryType?: string
+    memoTemplate?: string
+  }
+  taxonomyId?: string
+  scheduleMetadata?: {
+    method?: string
+    originalAmount?: number
+    residualValue?: number
+    usefulLifeMonths?: number
+    assetElementId?: string
+  }
+}
+
 // ── Client ──────────────────────────────────────────────────────────────
 
 export class LedgerClient {
@@ -483,4 +573,181 @@ export class LedgerClient {
       operationId: data?.operation_id as string | undefined,
     }
   }
+
+  // ── Schedules ──────────────────────────────────────────────────────
+
+  /**
+   * Create a schedule with pre-generated monthly facts.
+   */
+  async createSchedule(graphId: string, options: CreateScheduleOptions): Promise<ScheduleCreated> {
+    const body: CreateScheduleRequest = {
+      name: options.name,
+      element_ids: options.elementIds,
+      period_start: options.periodStart,
+      period_end: options.periodEnd,
+      monthly_amount: options.monthlyAmount,
+      entry_template: {
+        debit_element_id: options.entryTemplate.debitElementId,
+        credit_element_id: options.entryTemplate.creditElementId,
+        entry_type: options.entryTemplate.entryType,
+        memo_template: options.entryTemplate.memoTemplate,
+      },
+      taxonomy_id: options.taxonomyId,
+      schedule_metadata: options.scheduleMetadata
+        ? {
+            method: options.scheduleMetadata.method,
+            original_amount: options.scheduleMetadata.originalAmount,
+            residual_value: options.scheduleMetadata.residualValue,
+            useful_life_months: options.scheduleMetadata.usefulLifeMonths,
+            asset_element_id: options.scheduleMetadata.assetElementId,
+          }
+        : undefined,
+    }
+
+    const response = await createSchedule({
+      path: { graph_id: graphId },
+      body,
+    })
+
+    if (response.error) {
+      throw new Error(`Create schedule failed: ${JSON.stringify(response.error)}`)
+    }
+
+    const data = response.data as ScheduleCreatedResponse
+    return {
+      structureId: data.structure_id,
+      name: data.name,
+      taxonomyId: data.taxonomy_id,
+      totalPeriods: data.total_periods,
+      totalFacts: data.total_facts,
+    }
+  }
+
+  /**
+   * List all schedules for a graph.
+   */
+  async listSchedules(graphId: string): Promise<Schedule[]> {
+    const response = await listSchedules({
+      path: { graph_id: graphId },
+    })
+
+    if (response.error) {
+      throw new Error(`List schedules failed: ${JSON.stringify(response.error)}`)
+    }
+
+    const data = response.data as ScheduleListResponse
+    return (data.schedules ?? []).map((s: ScheduleSummaryResponse) => ({
+      structureId: s.structure_id,
+      name: s.name,
+      taxonomyName: s.taxonomy_name,
+      entryTemplate: s.entry_template ?? null,
+      scheduleMetadata: s.schedule_metadata ?? null,
+      totalPeriods: s.total_periods,
+      periodsWithEntries: s.periods_with_entries,
+    }))
+  }
+
+  /**
+   * Get facts for a schedule, optionally filtered by period.
+   */
+  async getScheduleFacts(
+    graphId: string,
+    structureId: string,
+    periodStart?: string,
+    periodEnd?: string
+  ): Promise<ScheduleFact[]> {
+    const response = await getScheduleFacts({
+      path: { graph_id: graphId, structure_id: structureId },
+      query: {
+        period_start: periodStart ?? null,
+        period_end: periodEnd ?? null,
+      },
+    })
+
+    if (response.error) {
+      throw new Error(`Get schedule facts failed: ${JSON.stringify(response.error)}`)
+    }
+
+    const data = response.data as ScheduleFactsResponse
+    return (data.facts ?? []).map((f: ScheduleFactResponse) => ({
+      elementId: f.element_id,
+      elementName: f.element_name,
+      value: f.value,
+      periodStart: f.period_start,
+      periodEnd: f.period_end,
+    }))
+  }
+
+  /**
+   * Get close status for all schedules in a fiscal period.
+   */
+  async getPeriodCloseStatus(
+    graphId: string,
+    periodStart: string,
+    periodEnd: string
+  ): Promise<PeriodCloseStatus> {
+    const response = await getPeriodCloseStatus({
+      path: { graph_id: graphId },
+      query: { period_start: periodStart, period_end: periodEnd },
+    })
+
+    if (response.error) {
+      throw new Error(`Get period close status failed: ${JSON.stringify(response.error)}`)
+    }
+
+    const data = response.data as PeriodCloseStatusResponse
+    return {
+      fiscalPeriodStart: data.fiscal_period_start,
+      fiscalPeriodEnd: data.fiscal_period_end,
+      periodStatus: data.period_status,
+      schedules: (data.schedules ?? []).map((s: PeriodCloseItemResponse) => ({
+        structureId: s.structure_id,
+        structureName: s.structure_name,
+        amount: s.amount,
+        status: s.status,
+        entryId: s.entry_id ?? null,
+      })),
+      totalDraft: data.total_draft,
+      totalPosted: data.total_posted,
+    }
+  }
+
+  /**
+   * Create a draft closing entry from a schedule's facts for a period.
+   */
+  async createClosingEntry(
+    graphId: string,
+    structureId: string,
+    postingDate: string,
+    periodStart: string,
+    periodEnd: string,
+    memo?: string
+  ): Promise<ClosingEntry> {
+    const body: CreateClosingEntryRequest = {
+      posting_date: postingDate,
+      period_start: periodStart,
+      period_end: periodEnd,
+      memo: memo ?? undefined,
+    }
+
+    const response = await createClosingEntry({
+      path: { graph_id: graphId, structure_id: structureId },
+      body,
+    })
+
+    if (response.error) {
+      throw new Error(`Create closing entry failed: ${JSON.stringify(response.error)}`)
+    }
+
+    const data = response.data as ClosingEntryResponse
+    return {
+      entryId: data.entry_id,
+      status: data.status,
+      postingDate: data.posting_date,
+      memo: data.memo,
+      debitElementId: data.debit_element_id,
+      creditElementId: data.credit_element_id,
+      amount: data.amount,
+    }
+  }
 }

package/sdk-extensions/ReportClient.d.ts

@@ -21,13 +21,17 @@ export interface Report {
 }
 import type { Structure } from './LedgerClient';
 export type { Structure } from './LedgerClient';
+export interface StatementPeriod {
+    start: string;
+    end: string;
+    label: string;
+}
 export interface StatementRow {
     elementId: string;
     elementQname: string;
     elementName: string;
     classification: string;
-    currentValue: number;
-    priorValue: number | null;
+    values: (number | null)[];
     isSubtotal: boolean;
     depth: number;
 }
@@ -36,10 +40,7 @@ export interface StatementData {
     structureId: string;
     structureName: string;
     structureType: string;
-    periodStart: string;
-    periodEnd: string;
-    comparativePeriodStart: string | null;
-    comparativePeriodEnd: string | null;
+    periods: StatementPeriod[];
     rows: StatementRow[];
     validation: {
         passed: boolean;
@@ -78,6 +79,11 @@ export interface PublishListMember {
     addedBy: string;
     addedAt: string;
 }
+export interface PeriodSpecInput {
+    start: string;
+    end: string;
+    label: string;
+}
 export interface CreateReportOptions {
     name: string;
     mappingId: string;
@@ -86,6 +92,8 @@ export interface CreateReportOptions {
     taxonomyId?: string;
     periodType?: string;
     comparative?: boolean;
+    /** When set, overrides periodStart/periodEnd/comparative with N explicit periods. */
+    periods?: PeriodSpecInput[];
 }
 export declare class ReportClient {
     private config;

package/sdk-extensions/ReportClient.js

@@ -19,17 +19,21 @@ class ReportClient {
      * Create a report — generates facts for all structures in the taxonomy.
      */
     async create(graphId, options) {
+        const body = {
+            name: options.name,
+            mapping_id: options.mappingId,
+            period_start: options.periodStart,
+            period_end: options.periodEnd,
+            taxonomy_id: options.taxonomyId ?? 'tax_usgaap_reporting',
+            period_type: options.periodType ?? 'quarterly',
+            comparative: options.comparative ?? true,
+        };
+        if (options.periods && options.periods.length > 0) {
+            body.periods = options.periods;
+        }
         const response = await (0, sdk_gen_1.createReport)({
             path: { graph_id: graphId },
-            body: {
-                name: options.name,
-                mapping_id: options.mappingId,
-                period_start: options.periodStart,
-                period_end: options.periodEnd,
-                taxonomy_id: options.taxonomyId ?? 'tax_usgaap_reporting',
-                period_type: options.periodType ?? 'quarterly',
-                comparative: options.comparative ?? true,
-            },
+            body,
         });
         if (response.error) {
             throw new Error(`Create report failed: ${JSON.stringify(response.error)}`);
@@ -79,17 +83,17 @@ class ReportClient {
             structureId: data.structure_id,
             structureName: data.structure_name,
             structureType: data.structure_type,
-            periodStart: data.period_start,
-            periodEnd: data.period_end,
-            comparativePeriodStart: data.comparative_period_start ?? null,
-            comparativePeriodEnd: data.comparative_period_end ?? null,
+            periods: (data.periods ?? []).map((p) => ({
+                start: p.start,
+                end: p.end,
+                label: p.label,
+            })),
             rows: (data.rows ?? []).map((r) => ({
                 elementId: r.element_id,
                 elementQname: r.element_qname,
                 elementName: r.element_name,
                 classification: r.classification,
-                currentValue: r.current_value,
-                priorValue: r.prior_value ?? null,
+                values: r.values ?? [],
                 isSubtotal: r.is_subtotal ?? false,
                 depth: r.depth ?? 0,
             })),