ofcoop-credit-shared-core 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,17 @@
+# ofcoop-credit-shared-core
+
+Shared-core domain kredit koperasi (loan, installment, credit policy) di atas primitive `ofcore`.
+
+## Commands
+- `npm run typecheck`
+- `npm run build`
+- `npm run verify:contract`
+- `npm run verify:surface`
+- `npm run verify:logic`
+- `npm run test`
+- `npm run ci:check`
+
+## Publish
+1. `npm run ci:check`
+2. `npm pack --dry-run`
+3. `npm publish --access public`

package/dist/OfcoopCreditCore.d.ts

@@ -0,0 +1,60 @@
+import type { CoreAdapterRegistry, CoreRuntime, CoreRuntimeStartOptions } from 'ofcore';
+import type { CoreRuntimeHooks } from 'ofcore';
+import type { DbAdapter } from 'ofcore';
+import type { HttpAdapter } from 'ofcore';
+import type { LoggerAdapter } from 'ofcore';
+import type { PlatformAdapter } from 'ofcore';
+import type { SocketAdapter } from 'ofcore';
+import type { ActivitySink } from 'ofcore';
+import type { ReadonlyStore, Store } from 'ofcore';
+import type { OfcoopCreditDomainEvent } from './services/createDbAdapterOfcoopCreditServices';
+import type { OfcoopCreditDomainServices } from './services/createDbAdapterOfcoopCreditServices';
+export type OfcoopCreditDomainServicesOverride = Partial<OfcoopCreditDomainServices>;
+export type OfcoopCreditDomainServicesFactory = () => Promise<OfcoopCreditDomainServices> | OfcoopCreditDomainServices;
+export type OfcoopCreditRuntimeHooks = Pick<CoreRuntimeHooks<OfcoopCreditDomainServices, never>, 'runMigrations' | 'runSeed' | 'onInit' | 'onStop'>;
+export interface OfcoopCreditRuntimeState {
+    phase: 'idle' | 'starting' | 'started' | 'stopping' | 'stopped' | 'error';
+    started: boolean;
+    startCount: number;
+    stopCount: number;
+    lastError: string | null;
+    lastTransitionAt: string;
+}
+export declare class OfcoopCreditCore {
+    private readonly runtime;
+    private readonly runtimeStateStore;
+    domainServices?: OfcoopCreditDomainServices;
+    readonly runtimeStore: ReadonlyStore<OfcoopCreditRuntimeState>;
+    constructor(runtime: CoreRuntime<OfcoopCreditDomainServices, never>, runtimeStateStore: Store<OfcoopCreditRuntimeState>);
+    static builder(): OfcoopCreditCoreBuilder;
+    get registry(): CoreAdapterRegistry | undefined;
+    start(options?: CoreRuntimeStartOptions): Promise<void>;
+    init(options?: CoreRuntimeStartOptions): Promise<void>;
+    stop(): Promise<void>;
+    restart(): Promise<void>;
+    isStarted(): boolean;
+    createCorrelationId(prefix?: string): string;
+    use(name: string, init: (core: OfcoopCreditCore) => Promise<void>, deps?: string[]): this;
+}
+export declare class OfcoopCreditCoreBuilder {
+    private readonly runtimeBuilder;
+    private domainServicesFactory?;
+    private domainServiceOverrides;
+    private runtimeHooks;
+    private domainEventSink?;
+    constructor();
+    withPlatformAdapter(factory: (core: CoreRuntime<any, any>) => PlatformAdapter): this;
+    withDbAdapter(factory: (core: CoreRuntime<any, any>) => DbAdapter): this;
+    withHttpAdapter(factory: (core: CoreRuntime<any, any>) => HttpAdapter): this;
+    withSocketAdapter(factory: (core: CoreRuntime<any, any>) => SocketAdapter): this;
+    withLoggerAdapter(factory: (core: CoreRuntime<any, any>) => LoggerAdapter): this;
+    withActivitySink(factory: (core: CoreRuntime<any, any>) => ActivitySink): this;
+    withExtension(name: string, factory: (core: CoreRuntime<any, any>) => unknown): this;
+    withDomainServicesFactory(factory: OfcoopCreditDomainServicesFactory): this;
+    overrideDomainServices(overrides: OfcoopCreditDomainServicesOverride): this;
+    withRuntimeHooks(hooks: Partial<OfcoopCreditRuntimeHooks>): this;
+    withMigrationRunner(runner: NonNullable<OfcoopCreditRuntimeHooks['runMigrations']>): this;
+    withSeedRunner(runner: NonNullable<OfcoopCreditRuntimeHooks['runSeed']>): this;
+    withDomainEventSink(sink: (event: OfcoopCreditDomainEvent) => Promise<void> | void): this;
+    build(): OfcoopCreditCore;
+}

package/dist/OfcoopCreditCore.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfcoopCreditCoreBuilder = exports.OfcoopCreditCore = void 0;
+const ofcore_1 = require("ofcore");
+const ofcore_2 = require("ofcore");
+const ofcore_3 = require("ofcore");
+const applyPendingMigrations_1 = require("./data/applyPendingMigrations");
+const createDbAdapterOfcoopCreditServices_1 = require("./services/createDbAdapterOfcoopCreditServices");
+class OfcoopCreditCore {
+    constructor(runtime, runtimeStateStore) {
+        this.runtime = runtime;
+        this.runtimeStateStore = runtimeStateStore;
+        this.runtimeStore = (0, ofcore_3.asReadonlyStore)(this.runtimeStateStore);
+    }
+    static builder() {
+        return new OfcoopCreditCoreBuilder();
+    }
+    get registry() {
+        return this.runtime.registry;
+    }
+    async start(options = {}) {
+        this.runtimeStateStore.setState({
+            phase: 'starting',
+            started: false,
+            lastError: null,
+            lastTransitionAt: new Date().toISOString(),
+        });
+        try {
+            await this.runtime.start(options);
+            this.domainServices = this.runtime.domainServices;
+            this.runtimeStateStore.setState((state) => ({
+                ...state,
+                phase: 'started',
+                started: true,
+                startCount: state.startCount + 1,
+                lastError: null,
+                lastTransitionAt: new Date().toISOString(),
+            }));
+        }
+        catch (error) {
+            this.runtimeStateStore.setState({
+                phase: 'error',
+                started: false,
+                lastError: error instanceof Error ? error.message : String(error),
+                lastTransitionAt: new Date().toISOString(),
+            });
+            throw error;
+        }
+    }
+    async init(options = {}) {
+        this.runtimeStateStore.setState({
+            phase: 'starting',
+            started: false,
+            lastError: null,
+            lastTransitionAt: new Date().toISOString(),
+        });
+        try {
+            await this.runtime.init(options);
+            this.domainServices = this.runtime.domainServices;
+            this.runtimeStateStore.setState((state) => ({
+                ...state,
+                phase: 'started',
+                started: true,
+                startCount: state.startCount + 1,
+                lastError: null,
+                lastTransitionAt: new Date().toISOString(),
+            }));
+        }
+        catch (error) {
+            this.runtimeStateStore.setState({
+                phase: 'error',
+                started: false,
+                lastError: error instanceof Error ? error.message : String(error),
+                lastTransitionAt: new Date().toISOString(),
+            });
+            throw error;
+        }
+    }
+    async stop() {
+        this.runtimeStateStore.setState({
+            phase: 'stopping',
+            started: this.runtime.isStarted(),
+            lastError: null,
+            lastTransitionAt: new Date().toISOString(),
+        });
+        try {
+            await this.runtime.stop();
+            this.runtimeStateStore.setState((state) => ({
+                ...state,
+                phase: 'stopped',
+                started: false,
+                stopCount: state.stopCount + 1,
+                lastError: null,
+                lastTransitionAt: new Date().toISOString(),
+            }));
+        }
+        catch (error) {
+            this.runtimeStateStore.setState({
+                phase: 'error',
+                started: this.runtime.isStarted(),
+                lastError: error instanceof Error ? error.message : String(error),
+                lastTransitionAt: new Date().toISOString(),
+            });
+            throw error;
+        }
+    }
+    async restart() {
+        this.runtimeStateStore.setState({
+            phase: 'starting',
+            started: this.runtime.isStarted(),
+            lastError: null,
+            lastTransitionAt: new Date().toISOString(),
+        });
+        try {
+            await this.runtime.restart();
+            this.domainServices = this.runtime.domainServices;
+            this.runtimeStateStore.setState((state) => ({
+                ...state,
+                phase: 'started',
+                started: true,
+                startCount: state.startCount + 1,
+                lastError: null,
+                lastTransitionAt: new Date().toISOString(),
+            }));
+        }
+        catch (error) {
+            this.runtimeStateStore.setState({
+                phase: 'error',
+                started: this.runtime.isStarted(),
+                lastError: error instanceof Error ? error.message : String(error),
+                lastTransitionAt: new Date().toISOString(),
+            });
+            throw error;
+        }
+    }
+    isStarted() {
+        return this.runtime.isStarted();
+    }
+    createCorrelationId(prefix = 'ofcoop-credit') {
+        return this.runtime.createCorrelationId(prefix);
+    }
+    use(name, init, deps = []) {
+        this.runtime.use(name, async () => init(this), deps);
+        return this;
+    }
+}
+exports.OfcoopCreditCore = OfcoopCreditCore;
+class OfcoopCreditCoreBuilder {
+    constructor() {
+        this.runtimeBuilder = ofcore_1.CoreRuntime.builder();
+        this.domainServiceOverrides = {};
+        this.runtimeHooks = {};
+        this.runtimeBuilder.withDbAdapter(() => new ofcore_2.InMemoryDbAdapter());
+    }
+    withPlatformAdapter(factory) {
+        this.runtimeBuilder.withPlatformAdapter(factory);
+        return this;
+    }
+    withDbAdapter(factory) {
+        this.runtimeBuilder.withDbAdapter(factory);
+        return this;
+    }
+    withHttpAdapter(factory) {
+        this.runtimeBuilder.withHttpAdapter(factory);
+        return this;
+    }
+    withSocketAdapter(factory) {
+        this.runtimeBuilder.withSocketAdapter(factory);
+        return this;
+    }
+    withLoggerAdapter(factory) {
+        this.runtimeBuilder.withLoggerAdapter(factory);
+        return this;
+    }
+    withActivitySink(factory) {
+        this.runtimeBuilder.withActivitySink(factory);
+        return this;
+    }
+    withExtension(name, factory) {
+        this.runtimeBuilder.withExtension(name, factory);
+        return this;
+    }
+    withDomainServicesFactory(factory) {
+        this.domainServicesFactory = factory;
+        return this;
+    }
+    overrideDomainServices(overrides) {
+        this.domainServiceOverrides = { ...this.domainServiceOverrides, ...overrides };
+        return this;
+    }
+    withRuntimeHooks(hooks) {
+        this.runtimeHooks = { ...this.runtimeHooks, ...hooks };
+        return this;
+    }
+    withMigrationRunner(runner) {
+        return this.withRuntimeHooks({ runMigrations: runner });
+    }
+    withSeedRunner(runner) {
+        return this.withRuntimeHooks({ runSeed: runner });
+    }
+    withDomainEventSink(sink) {
+        this.domainEventSink = sink;
+        return this;
+    }
+    build() {
+        const runtimeStateStore = (0, ofcore_3.createStore)({
+            phase: 'idle',
+            started: false,
+            startCount: 0,
+            stopCount: 0,
+            lastError: null,
+            lastTransitionAt: new Date().toISOString(),
+        });
+        const defaultRunMigrations = async (runtime) => {
+            const dbAdapter = runtime.registry?.dbAdapter;
+            if (!dbAdapter)
+                return;
+            await (0, applyPendingMigrations_1.applyPendingMigrations)(dbAdapter, runtime.registry?.loggerAdapter);
+        };
+        this.runtimeBuilder.withHooks({
+            ...this.runtimeHooks,
+            runMigrations: this.runtimeHooks.runMigrations ?? defaultRunMigrations,
+            createDomainServices: async (runtime) => {
+                const emitEvent = async (event) => {
+                    const errors = [];
+                    if (this.domainEventSink) {
+                        try {
+                            await this.domainEventSink(event);
+                        }
+                        catch (error) {
+                            errors.push(error);
+                        }
+                    }
+                    if (runtime.registry?.activitySink) {
+                        try {
+                            await runtime.registry.activitySink.publish({
+                                activityId: runtime.createCorrelationId('ofcoop-credit-event'),
+                                activityType: `ofcoop-credit.${event.name}`,
+                                occurredAt: event.occurredAt,
+                                scopeRef: {
+                                    domain: 'ofcoop-credit',
+                                    ...(event.tenantId ? { tenantId: event.tenantId } : {}),
+                                    ...(event.branchId ? { branchId: event.branchId } : {}),
+                                },
+                                payload: {
+                                    entityId: event.entityId ?? null,
+                                    ...(event.payload ?? {}),
+                                },
+                                correlationId: runtime.createCorrelationId('ofcoop-credit-corr'),
+                            });
+                        }
+                        catch (error) {
+                            errors.push(error);
+                        }
+                    }
+                    if (errors.length > 0) {
+                        throw errors[0];
+                    }
+                };
+                const base = this.domainServicesFactory
+                    ? await this.domainServicesFactory()
+                    : await (0, createDbAdapterOfcoopCreditServices_1.createDbAdapterOfcoopCreditServices)(runtime.registry?.dbAdapter ?? new ofcore_2.InMemoryDbAdapter(), {
+                        logger: runtime.registry?.loggerAdapter,
+                        emitEvent,
+                    });
+                return { ...base, ...this.domainServiceOverrides };
+            },
+        });
+        const runtime = this.runtimeBuilder.build();
+        return new OfcoopCreditCore(runtime, runtimeStateStore);
+    }
+}
+exports.OfcoopCreditCoreBuilder = OfcoopCreditCoreBuilder;

package/dist/contracts/CreditPolicyContract.d.ts

@@ -0,0 +1,37 @@
+export interface CreditPolicyContract {
+    id: string;
+    policyCode: string;
+    penaltyRatePerDay: number;
+    gracePeriodDays: number;
+    maxTenorMonths: number;
+    isActive: boolean;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface CreateCreditPolicyInput {
+    policyCode: string;
+    penaltyRatePerDay: number;
+    gracePeriodDays: number;
+    maxTenorMonths: number;
+    isActive?: boolean;
+    branchId?: string | null;
+    tenantId?: string | null;
+}
+export interface UpdateCreditPolicyInput {
+    penaltyRatePerDay?: number;
+    gracePeriodDays?: number;
+    maxTenorMonths?: number;
+    isActive?: boolean;
+}
+export interface CreditPolicyScope {
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface CreditPolicyServiceContract {
+    createCreditPolicy(input: CreateCreditPolicyInput): Promise<CreditPolicyContract>;
+    updateCreditPolicy(id: string, updates: UpdateCreditPolicyInput): Promise<CreditPolicyContract>;
+    getActiveCreditPolicy(scope: CreditPolicyScope): Promise<CreditPolicyContract | null>;
+}

package/dist/contracts/CreditPolicyContract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/InstallmentContract.d.ts

@@ -0,0 +1,39 @@
+export type InstallmentStatus = 'scheduled' | 'partial' | 'paid' | 'overdue';
+export interface InstallmentContract {
+    id: string;
+    loanId: string;
+    installmentNo: number;
+    dueDate: string;
+    principalDue: number;
+    serviceDue: number;
+    penaltyDue: number;
+    paidAmount: number;
+    status: InstallmentStatus;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface RecordInstallmentPaymentInput {
+    loanId: string;
+    installmentNo: number;
+    paidAmount: number;
+    paidAt: string;
+    referenceId?: string | null;
+    notes?: string | null;
+    branchId?: string | null;
+    tenantId?: string | null;
+}
+export interface InstallmentQueryOptions {
+    includeDeleted?: boolean;
+    status?: InstallmentStatus;
+    dueDateFrom?: string;
+    dueDateTo?: string;
+}
+export interface InstallmentServiceContract {
+    generateInstallmentSchedule(loanId: string): Promise<InstallmentContract[]>;
+    recordInstallmentPayment(input: RecordInstallmentPaymentInput): Promise<InstallmentContract>;
+    listInstallmentsByLoan(loanId: string, options?: InstallmentQueryOptions): Promise<InstallmentContract[]>;
+    listOverdueInstallments(options?: InstallmentQueryOptions): Promise<InstallmentContract[]>;
+}

package/dist/contracts/InstallmentContract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/LoanBoardContract.d.ts

@@ -0,0 +1,24 @@
+import type { LoanStatus } from './LoanContract';
+export interface LoanBoardItemContract {
+    loanId: string;
+    memberId: string;
+    tenantId?: string | null;
+    branchId?: string | null;
+    status: LoanStatus;
+    principalAmount: number;
+    outstandingAmount: number;
+    overdueInstallmentCount: number;
+    nextDueDate?: string | null;
+    lastPaymentDate?: string | null;
+}
+export interface LoanBoardScope {
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface LoanBoardQueryOptions {
+    memberId?: string;
+    status?: LoanStatus;
+}
+export interface LoanBoardServiceContract {
+    listLoanBoard(scope: LoanBoardScope, options?: LoanBoardQueryOptions): Promise<LoanBoardItemContract[]>;
+}

package/dist/contracts/LoanBoardContract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/LoanContract.d.ts

@@ -0,0 +1,36 @@
+export type LoanStatus = 'active' | 'closed' | 'defaulted';
+export interface LoanContract {
+    id: string;
+    memberId: string;
+    principalAmount: number;
+    tenorMonths: number;
+    serviceRate: number;
+    startDate: string;
+    status: LoanStatus;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface CreateLoanInput {
+    memberId: string;
+    principalAmount: number;
+    tenorMonths: number;
+    serviceRate: number;
+    startDate: string;
+    branchId?: string | null;
+    tenantId?: string | null;
+}
+export interface ListLoanOptions {
+    includeDeleted?: boolean;
+    status?: LoanStatus;
+    tenantId?: string | null;
+    branchId?: string | null;
+}
+export interface LoanServiceContract {
+    createLoan(input: CreateLoanInput): Promise<LoanContract>;
+    getLoanById(id: string): Promise<LoanContract | null>;
+    listLoansByMember(memberId: string, options?: ListLoanOptions): Promise<LoanContract[]>;
+    closeLoan(loanId: string): Promise<LoanContract>;
+}

package/dist/contracts/LoanContract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts/LoanDueWindowContract.d.ts

@@ -0,0 +1,25 @@
+import type { InstallmentStatus } from './InstallmentContract';
+export interface LoanDueWindowItemContract {
+    loanId: string;
+    memberId: string;
+    installmentNo: number;
+    dueDate: string;
+    installmentStatus: InstallmentStatus;
+    dueAmount: number;
+    paidAmount: number;
+    outstandingAmount: number;
+    tenantId?: string | null;
+    branchId?: string | null;
+}
+export interface LoanDueWindowScope {
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface LoanDueWindowQueryInput {
+    dateFrom: string;
+    dateTo: string;
+    memberId?: string;
+}
+export interface LoanDueWindowServiceContract {
+    listLoansDueInWindow(scope: LoanDueWindowScope, input: LoanDueWindowQueryInput): Promise<LoanDueWindowItemContract[]>;
+}

package/dist/contracts/LoanDueWindowContract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data/applyPendingMigrations.d.ts

@@ -0,0 +1,2 @@
+import type { DbAdapter, LoggerAdapter } from 'ofcore';
+export declare function applyPendingMigrations(adapter: DbAdapter, logger?: LoggerAdapter): Promise<void>;

package/dist/data/applyPendingMigrations.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPendingMigrations = applyPendingMigrations;
+const migrations_1 = require("./migrations");
+const noopLogger = {
+    logInfo() { },
+    logWarn() { },
+    logError() { },
+};
+async function applyPendingMigrations(adapter, logger = noopLogger) {
+    logger.logInfo('[ofcoop-credit] starting database migration process');
+    const sorted = [...migrations_1.migrations].sort((a, b) => a.toVersion - b.toVersion);
+    const targetVersion = sorted.length > 0 ? sorted[sorted.length - 1].toVersion : 0;
+    let currentVersion = await adapter.getSchemaVersion();
+    if (currentVersion == null || currentVersion < 0)
+        currentVersion = 0;
+    if (currentVersion >= targetVersion) {
+        logger.logInfo(`[ofcoop-credit] database already up-to-date at v${currentVersion}`);
+        return;
+    }
+    for (const migration of sorted) {
+        if (migration.toVersion > currentVersion) {
+            logger.logInfo(`[ofcoop-credit] applying migration v${migration.toVersion}`);
+            await migration.up(adapter);
+            await adapter.setSchemaVersion(migration.toVersion);
+            currentVersion = migration.toVersion;
+        }
+    }
+    logger.logInfo(`[ofcoop-credit] migration completed at v${currentVersion}`);
+}

package/dist/data/migrations.d.ts

@@ -0,0 +1,2 @@
+import type { Migration } from 'ofcore';
+export declare const migrations: Migration[];

package/dist/data/migrations.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrations = void 0;
+const schemas_1 = require("./schemas");
+exports.migrations = [
+    {
+        toVersion: 1,
+        up: async (adapter) => {
+            const tables = (0, schemas_1.getOfcoopCreditTableSchemas)();
+            for (const table of tables) {
+                try {
+                    await adapter.addTable(table);
+                }
+                catch {
+                    // Adapter may throw when table already exists; keep migration idempotent.
+                }
+            }
+        },
+    },
+];

package/dist/data/repositories.d.ts

@@ -0,0 +1,39 @@
+import type { DbAdapter } from 'ofcore';
+import type { CreditPolicyContract, CreditPolicyScope } from '../contracts/CreditPolicyContract';
+import type { InstallmentContract, InstallmentQueryOptions } from '../contracts/InstallmentContract';
+import type { ListLoanOptions, LoanContract } from '../contracts/LoanContract';
+export declare class LoanRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    create(row: LoanContract): Promise<LoanContract>;
+    update(id: string, updates: Partial<LoanContract>): Promise<LoanContract>;
+    getById(id: string): Promise<LoanContract | null>;
+    listByMember(memberId: string, options?: ListLoanOptions): Promise<LoanContract[]>;
+    list(options?: ListLoanOptions): Promise<LoanContract[]>;
+}
+export declare class InstallmentRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    createMany(rows: InstallmentContract[]): Promise<InstallmentContract[]>;
+    update(id: string, updates: Partial<InstallmentContract>): Promise<InstallmentContract>;
+    listByLoan(loanId: string, options?: InstallmentQueryOptions): Promise<InstallmentContract[]>;
+    list(options?: InstallmentQueryOptions & {
+        loanId?: string;
+    }): Promise<InstallmentContract[]>;
+    getByLoanAndInstallmentNo(loanId: string, installmentNo: number): Promise<InstallmentContract | null>;
+    listOverdue(options?: InstallmentQueryOptions): Promise<InstallmentContract[]>;
+}
+export declare class CreditPolicyRepository {
+    private readonly db;
+    constructor(db: DbAdapter);
+    create(row: CreditPolicyContract): Promise<CreditPolicyContract>;
+    update(id: string, updates: Partial<CreditPolicyContract>): Promise<CreditPolicyContract>;
+    getById(id: string): Promise<CreditPolicyContract | null>;
+    getActive(scope: CreditPolicyScope): Promise<CreditPolicyContract | null>;
+}
+export interface OfcoopCreditRepositories {
+    loanRepository: LoanRepository;
+    installmentRepository: InstallmentRepository;
+    creditPolicyRepository: CreditPolicyRepository;
+}
+export declare function createOfcoopCreditRepositories(db: DbAdapter): OfcoopCreditRepositories;