ofcoop-shared-core 0.1.0-alpha.0

package/dist/services/SavingComplianceSnapshotService.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSavingComplianceStatus = deriveSavingComplianceStatus;
+function deriveSavingComplianceStatus(monthlyWajibNominalIdr, wajibNetTotalIdr, hasPolicy) {
+    if (!hasPolicy)
+        return 'no-policy';
+    if (wajibNetTotalIdr >= monthlyWajibNominalIdr)
+        return 'compliant';
+    return 'underpaid';
+}

package/dist/services/SavingLedgerService.d.ts

@@ -0,0 +1,4 @@
+import type { SavingEntryInput, SavingLedgerServiceContract } from '../contracts/SavingLedgerContract';
+export interface SavingLedgerService extends SavingLedgerServiceContract {
+}
+export declare function assertValidSavingEntryInput(input: SavingEntryInput): void;

package/dist/services/SavingLedgerService.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidSavingEntryInput = assertValidSavingEntryInput;
+const errors_1 = require("./errors");
+function assertValidSavingEntryInput(input) {
+    if (!input.memberId?.trim())
+        throw (0, errors_1.invalidState)('memberId is required');
+    if (!input.transactionDate?.trim())
+        throw (0, errors_1.invalidState)('transactionDate is required');
+    if (Number.isNaN(Number(input.amount)) || Number(input.amount) <= 0) {
+        throw (0, errors_1.invalidState)('amount must be > 0');
+    }
+}

package/dist/services/SavingPolicyService.d.ts

@@ -0,0 +1,5 @@
+import type { SavingPolicyServiceContract, UpsertSavingPolicyInput } from '../contracts/SavingPolicyContract';
+export interface SavingPolicyService extends SavingPolicyServiceContract {
+}
+export declare function assertValidSavingPolicyInput(input: UpsertSavingPolicyInput): void;
+export declare function calculateWajibNetTotal(wajibCreditTotal: number, wajibDebitTotal: number): number;

package/dist/services/SavingPolicyService.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidSavingPolicyInput = assertValidSavingPolicyInput;
+exports.calculateWajibNetTotal = calculateWajibNetTotal;
+const errors_1 = require("./errors");
+function assertValidSavingPolicyInput(input) {
+    if (!input.koperasiId?.trim())
+        throw (0, errors_1.invalidState)('koperasiId is required');
+    if (!input.tenantId?.trim())
+        throw (0, errors_1.invalidState)('tenantId is required');
+    if (!input.effectiveDate?.trim())
+        throw (0, errors_1.invalidState)('effectiveDate is required');
+    if (input.simpananPokokNominalIdr < 0)
+        throw (0, errors_1.invalidState)('simpananPokokNominalIdr must be >= 0');
+    if (input.monthlyWajibNominalIdr < 0)
+        throw (0, errors_1.invalidState)('monthlyWajibNominalIdr must be >= 0');
+}
+function calculateWajibNetTotal(wajibCreditTotal, wajibDebitTotal) {
+    return wajibCreditTotal - wajibDebitTotal;
+}

package/dist/services/ShuConfigService.d.ts

@@ -0,0 +1,4 @@
+import type { ShuConfigServiceContract, UpsertShuConfigInput } from '../contracts/ShuConfigContract';
+export interface ShuConfigService extends ShuConfigServiceContract {
+}
+export declare function assertValidShuConfigInput(input: UpsertShuConfigInput): void;

package/dist/services/ShuConfigService.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidShuConfigInput = assertValidShuConfigInput;
+const errors_1 = require("./errors");
+function assertValidShuConfigInput(input) {
+    if (!input.koperasiId?.trim())
+        throw (0, errors_1.invalidState)('koperasiId is required');
+    if (!input.tenantId?.trim())
+        throw (0, errors_1.invalidState)('tenantId is required');
+    if (!input.effectiveDate?.trim())
+        throw (0, errors_1.invalidState)('effectiveDate is required');
+    const totalPercent = input.cadanganPercent + input.jasaUsahaPercent + input.jasaModalPercent;
+    if (totalPercent !== 100) {
+        throw (0, errors_1.invalidState)(`SHU config percent total must be exactly 100, got ${totalPercent}`);
+    }
+}

package/dist/services/ShuService.d.ts

@@ -0,0 +1,4 @@
+import type { CreateShuPeriodInput, ShuServiceContract } from '../contracts/ShuContract';
+export interface ShuService extends ShuServiceContract {
+}
+export declare function assertValidCreateShuPeriodInput(input: CreateShuPeriodInput): void;

package/dist/services/ShuService.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidCreateShuPeriodInput = assertValidCreateShuPeriodInput;
+const errors_1 = require("./errors");
+function assertValidCreateShuPeriodInput(input) {
+    if (!input.periodCode?.trim())
+        throw (0, errors_1.invalidState)('periodCode is required');
+    if (!input.startDate?.trim())
+        throw (0, errors_1.invalidState)('startDate is required');
+    if (!input.endDate?.trim())
+        throw (0, errors_1.invalidState)('endDate is required');
+    if (!input.tenantId?.trim())
+        throw (0, errors_1.invalidState)('tenantId is required');
+}

package/dist/services/createActivityAuditTrailProvider.d.ts

@@ -0,0 +1,22 @@
+import type { ActivityRecord } from 'ofcore';
+import type { AuditTrailEvent, AuditTrailQueryInput } from './AuditTrailQueryService';
+export interface ActivityRecordQuery {
+    fromTimestamp?: string;
+    toTimestamp?: string;
+    tenantId?: string | null;
+    branchId?: string | null;
+    limit?: number;
+    activityTypes?: string[];
+}
+export interface ActivityRecordSource {
+    listActivityRecords(query: ActivityRecordQuery): Promise<ActivityRecord[]>;
+}
+export interface CreateActivityAuditTrailProviderOptions {
+    eventCatalog?: string[];
+}
+export declare function createActivityAuditTrailProvider(source: ActivityRecordSource, options?: CreateActivityAuditTrailProviderOptions): {
+    auditTrailProvider: {
+        listEvents: (query: AuditTrailQueryInput) => Promise<AuditTrailEvent[]>;
+    };
+    eventCatalog: string[];
+};

package/dist/services/createActivityAuditTrailProvider.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActivityAuditTrailProvider = createActivityAuditTrailProvider;
+const createOfauthCompositionProviders_1 = require("./createOfauthCompositionProviders");
+const createOfcoopDomainAuditCompositionProviders_1 = require("./createOfcoopDomainAuditCompositionProviders");
+function unique(values) {
+    return [...new Set(values)];
+}
+function toDomain(activityType) {
+    if (activityType.startsWith('ofcoop.'))
+        return 'ofcoop';
+    if (activityType.startsWith('ofcoop-credit.'))
+        return 'ofcoop-credit';
+    if (activityType.startsWith('ofauth.'))
+        return 'ofauth';
+    return 'external';
+}
+function toEventType(activityType) {
+    if (activityType.startsWith('ofcoop.'))
+        return activityType.slice('ofcoop.'.length);
+    if (activityType.startsWith('ofcoop-credit.'))
+        return activityType.slice('ofcoop-credit.'.length);
+    if (activityType.startsWith('ofauth.'))
+        return activityType.slice('ofauth.'.length).toUpperCase();
+    return activityType;
+}
+function toActivityTypes(eventTypes) {
+    if (!eventTypes || eventTypes.length === 0)
+        return undefined;
+    const out = eventTypes.flatMap((eventType) => [
+        `ofcoop.${eventType}`,
+        `ofcoop-credit.${eventType}`,
+        `ofauth.${eventType.toLowerCase()}`,
+    ]);
+    return unique(out);
+}
+function createActivityAuditTrailProvider(source, options = {}) {
+    const eventCatalog = unique(options.eventCatalog ??
+        [...createOfcoopDomainAuditCompositionProviders_1.OFCOOP_AUDIT_EVENT_CATALOG, ...createOfcoopDomainAuditCompositionProviders_1.OFCOOP_CREDIT_AUDIT_EVENT_CATALOG, ...createOfauthCompositionProviders_1.OFAUTH_AUDIT_EVENT_CATALOG]);
+    return {
+        eventCatalog,
+        auditTrailProvider: {
+            async listEvents(query) {
+                const rows = await source.listActivityRecords({
+                    fromTimestamp: query.fromTimestamp,
+                    toTimestamp: query.toTimestamp,
+                    tenantId: query.scope?.tenantId,
+                    branchId: query.scope?.branchId,
+                    limit: query.limit,
+                    activityTypes: toActivityTypes(query.eventTypes),
+                });
+                return rows
+                    .map((row) => {
+                    const payloadMemberId = typeof row.payload?.memberId === 'string' ? row.payload.memberId : null;
+                    const domain = toDomain(row.activityType);
+                    return {
+                        eventId: row.activityId,
+                        sourceDomain: domain,
+                        eventType: toEventType(row.activityType),
+                        occurredAt: row.occurredAt,
+                        memberId: payloadMemberId ?? query.memberId ?? undefined,
+                        tenantId: row.scopeRef?.tenantId,
+                        branchId: row.scopeRef?.branchId,
+                        summary: typeof row.payload?.entityId === 'string' && row.payload.entityId
+                            ? `entity:${row.payload.entityId}`
+                            : row.activityType,
+                    };
+                })
+                    .sort((a, b) => b.occurredAt.localeCompare(a.occurredAt));
+            },
+        },
+    };
+}

package/dist/services/createAuditTrailCompositionProvider.d.ts

@@ -0,0 +1,13 @@
+import type { AuditTrailEvent, AuditTrailQueryInput } from './AuditTrailQueryService';
+interface AuditTrailProviderRef {
+    listEvents: (query: AuditTrailQueryInput) => Promise<AuditTrailEvent[]>;
+}
+interface AuditTrailProviderSourceRef {
+    provider: AuditTrailProviderRef;
+    eventCatalog?: string[];
+}
+export declare function createAuditTrailCompositionProvider(sources: AuditTrailProviderSourceRef[]): {
+    auditTrailProvider: AuditTrailProviderRef;
+    eventCatalog: string[];
+};
+export {};

package/dist/services/createAuditTrailCompositionProvider.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuditTrailCompositionProvider = createAuditTrailCompositionProvider;
+function uniqueCatalog(input) {
+    return [...new Set(input)];
+}
+function createAuditTrailCompositionProvider(sources) {
+    const eventCatalog = uniqueCatalog(sources.flatMap((source) => source.eventCatalog ?? []));
+    return {
+        eventCatalog,
+        auditTrailProvider: {
+            async listEvents(query) {
+                const batches = await Promise.all(sources.map((source) => source.provider.listEvents(query)));
+                return batches
+                    .flat()
+                    .sort((a, b) => b.occurredAt.localeCompare(a.occurredAt))
+                    .slice(0, query.limit && query.limit > 0 ? query.limit : 100);
+            },
+        },
+    };
+}

package/dist/services/createDbAdapterOfcoopServices.d.ts

@@ -0,0 +1,20 @@
+import type { DbAdapter } from 'ofcore';
+import type { MemberServiceContract } from '../contracts/MemberContract';
+import type { MemberNumberPolicyServiceContract } from '../contracts/MemberNumberPolicyContract';
+import type { SavingLedgerServiceContract } from '../contracts/SavingLedgerContract';
+import type { SavingPolicyServiceContract } from '../contracts/SavingPolicyContract';
+import type { SavingComplianceSnapshotServiceContract } from '../contracts/SavingComplianceSnapshotContract';
+import type { ShuConfigServiceContract } from '../contracts/ShuConfigContract';
+import type { ShuServiceContract } from '../contracts/ShuContract';
+import type { ServiceRuntimeOptions } from './impl/runtimeSupport';
+export type { OfcoopDomainEvent, OfcoopDomainEventName, ServiceRuntimeOptions } from './impl/runtimeSupport';
+export interface OfcoopDomainServices {
+    memberService: MemberServiceContract;
+    memberNumberPolicyService: MemberNumberPolicyServiceContract;
+    savingLedgerService: SavingLedgerServiceContract;
+    savingPolicyService: SavingPolicyServiceContract;
+    savingComplianceSnapshotService: SavingComplianceSnapshotServiceContract;
+    shuConfigService: ShuConfigServiceContract;
+    shuService: ShuServiceContract;
+}
+export declare function createDbAdapterOfcoopServices(dbAdapter: DbAdapter, options?: ServiceRuntimeOptions): Promise<OfcoopDomainServices>;

package/dist/services/createDbAdapterOfcoopServices.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDbAdapterOfcoopServices = createDbAdapterOfcoopServices;
+const repositories_1 = require("../data/repositories");
+const DbAdapterMemberNumberPolicyService_1 = require("./impl/DbAdapterMemberNumberPolicyService");
+const DbAdapterMemberService_1 = require("./impl/DbAdapterMemberService");
+const DbAdapterSavingComplianceSnapshotService_1 = require("./impl/DbAdapterSavingComplianceSnapshotService");
+const DbAdapterSavingLedgerService_1 = require("./impl/DbAdapterSavingLedgerService");
+const DbAdapterSavingPolicyService_1 = require("./impl/DbAdapterSavingPolicyService");
+const DbAdapterShuConfigService_1 = require("./impl/DbAdapterShuConfigService");
+const DbAdapterShuService_1 = require("./impl/DbAdapterShuService");
+async function createDbAdapterOfcoopServices(dbAdapter, options = {}) {
+    const repositories = (0, repositories_1.createOfcoopRepositories)(dbAdapter);
+    return {
+        memberService: new DbAdapterMemberService_1.DbAdapterMemberService(dbAdapter, repositories, options),
+        memberNumberPolicyService: new DbAdapterMemberNumberPolicyService_1.DbAdapterMemberNumberPolicyService(repositories),
+        savingLedgerService: new DbAdapterSavingLedgerService_1.DbAdapterSavingLedgerService(dbAdapter, repositories, options),
+        savingPolicyService: new DbAdapterSavingPolicyService_1.DbAdapterSavingPolicyService(repositories, options),
+        savingComplianceSnapshotService: new DbAdapterSavingComplianceSnapshotService_1.DbAdapterSavingComplianceSnapshotService(repositories),
+        shuConfigService: new DbAdapterShuConfigService_1.DbAdapterShuConfigService(repositories, options),
+        shuService: new DbAdapterShuService_1.DbAdapterShuService(dbAdapter, repositories, options),
+    };
+}

package/dist/services/createMember360CompositionProviders.d.ts

@@ -0,0 +1,6 @@
+import type { Member360Providers } from './Member360Service';
+interface Member360ProviderSourceRef {
+    provider: Pick<Member360Providers, 'getCreditByMember' | 'getAuditByMember' | 'getSettlementSummaryByMember'>;
+}
+export declare function createMember360CompositionProviders(sources: Member360ProviderSourceRef[]): Pick<Member360Providers, 'getCreditByMember' | 'getAuditByMember' | 'getSettlementSummaryByMember'>;
+export {};

package/dist/services/createMember360CompositionProviders.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMember360CompositionProviders = createMember360CompositionProviders;
+function sortAuditDesc(rows) {
+    return [...rows].sort((a, b) => b.occurredAt.localeCompare(a.occurredAt));
+}
+async function resolveFirstCredit(sources, memberId, scope) {
+    for (const source of sources) {
+        if (!source.provider.getCreditByMember)
+            continue;
+        const result = await source.provider.getCreditByMember(memberId, scope);
+        if (result)
+            return result;
+    }
+    return null;
+}
+async function resolveMergedAudit(sources, memberId, scope) {
+    const batches = await Promise.all(sources.map((source) => source.provider.getAuditByMember?.(memberId, scope) ?? Promise.resolve([])));
+    return sortAuditDesc(batches.flat()).slice(0, 100);
+}
+async function resolveFirstSettlement(sources, memberId, scope) {
+    for (const source of sources) {
+        if (!source.provider.getSettlementSummaryByMember)
+            continue;
+        const result = await source.provider.getSettlementSummaryByMember(memberId, scope);
+        if (result)
+            return result;
+    }
+    return null;
+}
+function createMember360CompositionProviders(sources) {
+    return {
+        async getCreditByMember(memberId, scope) {
+            return resolveFirstCredit(sources, memberId, scope);
+        },
+        async getAuditByMember(memberId, scope) {
+            return resolveMergedAudit(sources, memberId, scope);
+        },
+        async getSettlementSummaryByMember(memberId, scope) {
+            return resolveFirstSettlement(sources, memberId, scope);
+        },
+    };
+}

package/dist/services/createOfauthCompositionProviders.d.ts

@@ -0,0 +1,39 @@
+import type { AuditTrailEvent, AuditTrailQueryInput } from './AuditTrailQueryService';
+import type { Member360Providers } from './Member360Service';
+export declare const OFAUTH_AUDIT_EVENT_CATALOG: readonly ["LOGIN_SUCCESS", "LOGIN_FAILED", "LOCKOUT_TRIGGERED", "SESSION_REVOKED", "CONTEXT_SWITCHED", "STEP_UP_CHALLENGED", "STEP_UP_PASSED", "STEP_UP_FAILED"];
+type OfauthAuditEventType = (typeof OFAUTH_AUDIT_EVENT_CATALOG)[number];
+interface OfauthAuditEventRef {
+    eventId: string;
+    eventType: OfauthAuditEventType;
+    identityId?: string;
+    sessionId?: string;
+    scopeRef?: {
+        tenantId?: string;
+        branchId?: string;
+        attributes?: Record<string, string>;
+    };
+    result: 'success' | 'failed';
+    reasonCode?: string;
+    timestamp: string;
+}
+interface OfauthAuditServiceRef {
+    queryEvents: (query: {
+        identityId?: string;
+        sessionId?: string;
+        eventTypes?: OfauthAuditEventType[];
+        fromTimestamp?: string;
+        toTimestamp?: string;
+    }) => Promise<OfauthAuditEventRef[]>;
+}
+interface OfauthIdentityLinkResolver {
+    resolveIdentityIdsByMemberId: (memberId: string) => Promise<string[]>;
+    resolveMemberIdByIdentityId?: (identityId: string) => Promise<string | null>;
+}
+export declare function createOfauthCompositionProviders(authAuditService: OfauthAuditServiceRef, resolver: OfauthIdentityLinkResolver): {
+    member360: Pick<Member360Providers, 'getAuditByMember'>;
+    auditTrailProvider: {
+        listEvents: (query: AuditTrailQueryInput) => Promise<AuditTrailEvent[]>;
+    };
+    eventCatalog: string[];
+};
+export {};

package/dist/services/createOfauthCompositionProviders.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFAUTH_AUDIT_EVENT_CATALOG = void 0;
+exports.createOfauthCompositionProviders = createOfauthCompositionProviders;
+exports.OFAUTH_AUDIT_EVENT_CATALOG = [
+    'LOGIN_SUCCESS',
+    'LOGIN_FAILED',
+    'LOCKOUT_TRIGGERED',
+    'SESSION_REVOKED',
+    'CONTEXT_SWITCHED',
+    'STEP_UP_CHALLENGED',
+    'STEP_UP_PASSED',
+    'STEP_UP_FAILED',
+];
+function isOfauthEventType(value) {
+    return exports.OFAUTH_AUDIT_EVENT_CATALOG.includes(value);
+}
+function toMember360Audit(event) {
+    return {
+        eventId: event.eventId,
+        eventType: event.eventType,
+        occurredAt: event.timestamp,
+        message: event.reasonCode ?? event.result,
+    };
+}
+function toAuditTrailEvent(event, memberId) {
+    return {
+        eventId: event.eventId,
+        sourceDomain: 'ofauth',
+        eventType: event.eventType,
+        occurredAt: event.timestamp,
+        memberId: memberId ?? undefined,
+        tenantId: event.scopeRef?.tenantId,
+        branchId: event.scopeRef?.branchId,
+        summary: event.reasonCode ?? event.result,
+    };
+}
+function createOfauthCompositionProviders(authAuditService, resolver) {
+    const member360 = {
+        async getAuditByMember(memberId) {
+            const identityIds = await resolver.resolveIdentityIdsByMemberId(memberId);
+            if (identityIds.length === 0)
+                return [];
+            const all = await Promise.all(identityIds.map((identityId) => authAuditService.queryEvents({ identityId })));
+            return all
+                .flat()
+                .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+                .slice(0, 100)
+                .map(toMember360Audit);
+        },
+    };
+    const auditTrailProvider = {
+        async listEvents(query) {
+            let identityIds = [];
+            if (query.memberId) {
+                identityIds = await resolver.resolveIdentityIdsByMemberId(query.memberId);
+                if (identityIds.length === 0)
+                    return [];
+            }
+            const requestedTypes = (query.eventTypes ?? []).filter(isOfauthEventType);
+            const baseQuery = {
+                ...(query.fromTimestamp ? { fromTimestamp: query.fromTimestamp } : {}),
+                ...(query.toTimestamp ? { toTimestamp: query.toTimestamp } : {}),
+                ...(requestedTypes.length > 0 ? { eventTypes: requestedTypes } : {}),
+            };
+            const batches = identityIds.length > 0
+                ? await Promise.all(identityIds.map((identityId) => authAuditService.queryEvents({ ...baseQuery, identityId })))
+                : [await authAuditService.queryEvents(baseQuery)];
+            const mapped = await Promise.all(batches
+                .flat()
+                .map(async (event) => toAuditTrailEvent(event, event.identityId ? (await resolver.resolveMemberIdByIdentityId?.(event.identityId)) ?? null : null)));
+            return mapped;
+        },
+    };
+    return {
+        member360,
+        auditTrailProvider,
+        eventCatalog: [...exports.OFAUTH_AUDIT_EVENT_CATALOG],
+    };
+}

package/dist/services/createOfcoopCreditCompositionProviders.d.ts

@@ -0,0 +1,59 @@
+import type { DashboardSummaryProviders } from './DashboardSummaryService';
+import type { Member360Providers } from './Member360Service';
+import type { ReportSummaryProviders } from './ReportSummaryService';
+interface LoanRef {
+    id: string;
+    memberId: string;
+    principalAmount: number;
+    status: 'active' | 'closed' | 'defaulted';
+    startDate: string;
+}
+interface LoanBoardItemRef {
+    loanId: string;
+    memberId: string;
+    status: 'active' | 'closed' | 'defaulted';
+    principalAmount: number;
+    outstandingAmount: number;
+    overdueInstallmentCount: number;
+    nextDueDate?: string | null;
+}
+interface LoanDueWindowItemRef {
+    loanId: string;
+    memberId: string;
+    dueDate: string;
+    installmentStatus: 'scheduled' | 'partial' | 'paid' | 'overdue';
+    outstandingAmount: number;
+}
+interface CreditServicesRef {
+    loanService: {
+        listLoansByMember: (memberId: string, options?: {
+            includeDeleted?: boolean;
+            tenantId?: string | null;
+            branchId?: string | null;
+        }) => Promise<LoanRef[]>;
+    };
+    loanBoardService: {
+        listLoanBoard: (scope: {
+            tenantId: string;
+            branchId?: string | null;
+        }, options?: {
+            memberId?: string;
+        }) => Promise<LoanBoardItemRef[]>;
+    };
+    loanDueWindowService: {
+        listLoansDueInWindow: (scope: {
+            tenantId: string;
+            branchId?: string | null;
+        }, input: {
+            dateFrom: string;
+            dateTo: string;
+            memberId?: string;
+        }) => Promise<LoanDueWindowItemRef[]>;
+    };
+}
+export declare function createOfcoopCreditCompositionProviders(credit: CreditServicesRef): {
+    member360: Pick<Member360Providers, 'getCreditByMember' | 'getSettlementSummaryByMember'>;
+    dashboard: Pick<DashboardSummaryProviders, 'getLoanStatusComposition' | 'getLoanAgingBuckets' | 'getTotalOverdueAmount' | 'getAnggotaCreditSummary' | 'getLoanRiskMap'>;
+    report: Pick<ReportSummaryProviders, 'getCreditSummary'>;
+};
+export {};