ofcoop-shared-core 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,18 @@
+# ofcoop-shared-core
+
+Shared-core domain koperasi umum (anggota, simpanan, SHU, dan policy) di atas primitive `ofcore`.
+
+## Commands
+- `npm run typecheck`
+- `npm run build`
+- `npm run verify:contract`
+- `npm run verify:surface`
+- `npm run verify:ofcore-primitives`
+- `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/OfcoopCore.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 { OfcoopDomainEvent } from './services/createDbAdapterOfcoopServices';
+import type { OfcoopDomainServices } from './services/createDbAdapterOfcoopServices';
+export type OfcoopDomainServicesOverride = Partial<OfcoopDomainServices>;
+export type OfcoopDomainServicesFactory = () => Promise<OfcoopDomainServices> | OfcoopDomainServices;
+export type OfcoopRuntimeHooks = Pick<CoreRuntimeHooks<OfcoopDomainServices, never>, 'runMigrations' | 'runSeed' | 'onInit' | 'onStop'>;
+export interface OfcoopRuntimeState {
+    phase: 'idle' | 'starting' | 'started' | 'stopping' | 'stopped' | 'error';
+    started: boolean;
+    startCount: number;
+    stopCount: number;
+    lastError: string | null;
+    lastTransitionAt: string;
+}
+export declare class OfcoopCore {
+    private readonly runtime;
+    private readonly runtimeStateStore;
+    domainServices?: OfcoopDomainServices;
+    readonly runtimeStore: ReadonlyStore<OfcoopRuntimeState>;
+    constructor(runtime: CoreRuntime<OfcoopDomainServices, never>, runtimeStateStore: Store<OfcoopRuntimeState>);
+    static builder(): OfcoopCoreBuilder;
+    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: OfcoopCore) => Promise<void>, deps?: string[]): this;
+}
+export declare class OfcoopCoreBuilder {
+    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: OfcoopDomainServicesFactory): this;
+    overrideDomainServices(overrides: OfcoopDomainServicesOverride): this;
+    withRuntimeHooks(hooks: Partial<OfcoopRuntimeHooks>): this;
+    withMigrationRunner(runner: NonNullable<OfcoopRuntimeHooks['runMigrations']>): this;
+    withSeedRunner(runner: NonNullable<OfcoopRuntimeHooks['runSeed']>): this;
+    withDomainEventSink(sink: (event: OfcoopDomainEvent) => Promise<void> | void): this;
+    build(): OfcoopCore;
+}

package/dist/OfcoopCore.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfcoopCoreBuilder = exports.OfcoopCore = void 0;
+const ofcore_1 = require("ofcore");
+const ofcore_2 = require("ofcore");
+const ofcore_3 = require("ofcore");
+const applyPendingMigrations_1 = require("./data/applyPendingMigrations");
+const createDbAdapterOfcoopServices_1 = require("./services/createDbAdapterOfcoopServices");
+class OfcoopCore {
+    constructor(runtime, runtimeStateStore) {
+        this.runtime = runtime;
+        this.runtimeStateStore = runtimeStateStore;
+        this.runtimeStore = (0, ofcore_3.asReadonlyStore)(this.runtimeStateStore);
+    }
+    static builder() {
+        return new OfcoopCoreBuilder();
+    }
+    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') {
+        return this.runtime.createCorrelationId(prefix);
+    }
+    use(name, init, deps = []) {
+        this.runtime.use(name, async () => init(this), deps);
+        return this;
+    }
+}
+exports.OfcoopCore = OfcoopCore;
+class OfcoopCoreBuilder {
+    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-event'),
+                                activityType: `ofcoop.${event.name}`,
+                                occurredAt: event.occurredAt,
+                                scopeRef: {
+                                    domain: 'ofcoop',
+                                    ...(event.tenantId ? { tenantId: event.tenantId } : {}),
+                                    ...(event.branchId ? { branchId: event.branchId } : {}),
+                                },
+                                payload: {
+                                    entityId: event.entityId ?? null,
+                                    ...(event.payload ?? {}),
+                                },
+                                correlationId: runtime.createCorrelationId('ofcoop-corr'),
+                            });
+                        }
+                        catch (error) {
+                            errors.push(error);
+                        }
+                    }
+                    if (errors.length > 0) {
+                        throw errors[0];
+                    }
+                };
+                const base = this.domainServicesFactory
+                    ? await this.domainServicesFactory()
+                    : await (0, createDbAdapterOfcoopServices_1.createDbAdapterOfcoopServices)(runtime.registry?.dbAdapter ?? new ofcore_2.InMemoryDbAdapter(), {
+                        logger: runtime.registry?.loggerAdapter,
+                        emitEvent,
+                    });
+                return { ...base, ...this.domainServiceOverrides };
+            },
+        });
+        const runtime = this.runtimeBuilder.build();
+        return new OfcoopCore(runtime, runtimeStateStore);
+    }
+}
+exports.OfcoopCoreBuilder = OfcoopCoreBuilder;

package/dist/contracts/MemberContract.d.ts

@@ -0,0 +1,52 @@
+export type MemberStatus = 'active' | 'inactive' | 'exited';
+export interface MemberContract {
+    id: string;
+    memberNumber: string;
+    fullName: string;
+    status: MemberStatus;
+    joinDate: string;
+    exitDate?: string | null;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface CreateMemberInput {
+    memberNumber: string;
+    fullName: string;
+    joinDate: string;
+    branchId?: string | null;
+    tenantId?: string | null;
+}
+export interface UpdateMemberInput {
+    fullName?: string;
+    memberNumber?: string;
+}
+export interface MemberQueryOptions {
+    includeDeleted?: boolean;
+    status?: MemberStatus;
+    tenantId?: string | null;
+    branchId?: string | null;
+}
+export interface MemberWaConsentInput {
+    granted: boolean;
+    source?: string | null;
+    note?: string | null;
+}
+export interface MemberExitInput {
+    reason?: string | null;
+    requestedBy?: string | null;
+    referenceId?: string | null;
+}
+export interface MemberServiceContract {
+    createMember(input: CreateMemberInput): Promise<MemberContract>;
+    updateMember(id: string, updates: UpdateMemberInput): Promise<MemberContract>;
+    getMemberById(id: string): Promise<MemberContract | null>;
+    listMembers(options?: MemberQueryOptions): Promise<MemberContract[]>;
+    changeMemberStatus(id: string, status: MemberStatus): Promise<MemberContract>;
+    setMemberWaConsent(id: string, consent: MemberWaConsentInput): Promise<MemberContract>;
+    requestMemberExit(id: string, payload: MemberExitInput): Promise<MemberContract>;
+    settleMemberExit(id: string, payload: MemberExitInput): Promise<MemberContract>;
+    cancelMemberExit(id: string, payload: MemberExitInput): Promise<MemberContract>;
+}

package/dist/contracts/MemberContract.js

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

package/dist/contracts/MemberNumberPolicyContract.d.ts

@@ -0,0 +1,44 @@
+export type CounterResetPolicy = 'never' | 'yearly';
+export interface MemberNumberPolicyContract {
+    id: string;
+    koperasiId: string;
+    branchId?: string | null;
+    tenantId?: string | null;
+    prefix?: string | null;
+    includeYear: boolean;
+    includeMonth: boolean;
+    separator: string;
+    paddingDigits: number;
+    counterResetPolicy: CounterResetPolicy;
+    counterStart: number;
+    manualOverrideAllowed: boolean;
+    effectiveDate: string;
+    approvalRef?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface MemberNumberPolicyScope {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface UpsertMemberNumberPolicyInput {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+    prefix?: string | null;
+    includeYear: boolean;
+    includeMonth: boolean;
+    separator: string;
+    paddingDigits: number;
+    counterResetPolicy: CounterResetPolicy;
+    counterStart: number;
+    manualOverrideAllowed: boolean;
+    effectiveDate: string;
+    approvalRef?: string | null;
+}
+export interface MemberNumberPolicyServiceContract {
+    getActiveMemberNumberPolicy(scope: MemberNumberPolicyScope): Promise<MemberNumberPolicyContract | null>;
+    upsertMemberNumberPolicy(input: UpsertMemberNumberPolicyInput): Promise<MemberNumberPolicyContract>;
+}

package/dist/contracts/MemberNumberPolicyContract.js

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

package/dist/contracts/SavingComplianceSnapshotContract.d.ts

@@ -0,0 +1,34 @@
+export type SavingComplianceStatus = 'compliant' | 'underpaid' | 'no-policy';
+export interface SavingComplianceSnapshotContract {
+    id: string;
+    memberId: string;
+    koperasiId: string;
+    tenantId?: string | null;
+    branchId?: string | null;
+    referenceDate: string;
+    monthlyWajibNominalIdr: number;
+    wajibCreditTotalIdr: number;
+    wajibDebitTotalIdr: number;
+    wajibNetTotalIdr: number;
+    status: SavingComplianceStatus;
+    monthsInArrears: number;
+    recommendedAction: string;
+    metadata?: Record<string, unknown>;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface SavingComplianceSnapshotScope {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface SavingComplianceSnapshotQueryOptions {
+    memberId?: string;
+    status?: SavingComplianceStatus;
+    includeDeleted?: boolean;
+}
+export interface SavingComplianceSnapshotServiceContract {
+    listComplianceSnapshots(scope: SavingComplianceSnapshotScope, options?: SavingComplianceSnapshotQueryOptions): Promise<SavingComplianceSnapshotContract[]>;
+    getComplianceSnapshotByMember(memberId: string, scope: SavingComplianceSnapshotScope): Promise<SavingComplianceSnapshotContract | null>;
+}

package/dist/contracts/SavingComplianceSnapshotContract.js

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

package/dist/contracts/SavingLedgerContract.d.ts

@@ -0,0 +1,49 @@
+export type SavingType = 'pokok' | 'wajib' | 'sukarela';
+export type SavingEntryType = 'credit' | 'debit';
+export interface SavingLedgerContract {
+    id: string;
+    memberId: string;
+    savingType: SavingType;
+    entryType: SavingEntryType;
+    amount: number;
+    transactionDate: string;
+    referenceType?: string | null;
+    referenceId?: string | null;
+    notes?: string | null;
+    branchId?: string | null;
+    tenantId?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface SavingEntryInput {
+    memberId: string;
+    savingType: SavingType;
+    amount: number;
+    transactionDate: string;
+    referenceType?: string | null;
+    referenceId?: string | null;
+    notes?: string | null;
+    branchId?: string | null;
+    tenantId?: string | null;
+}
+export interface SavingBalance {
+    pokok: number;
+    wajib: number;
+    sukarela: number;
+    total: number;
+}
+export interface SavingLedgerQueryOptions {
+    includeDeleted?: boolean;
+    dateFrom?: string;
+    dateTo?: string;
+    tenantId?: string | null;
+    branchId?: string | null;
+}
+export interface SavingLedgerServiceContract {
+    recordSavingCredit(input: SavingEntryInput): Promise<SavingLedgerContract>;
+    recordSavingDebit(input: SavingEntryInput): Promise<SavingLedgerContract>;
+    recordSavingWithdrawal(input: SavingEntryInput): Promise<SavingLedgerContract>;
+    listSavingEntriesByMember(memberId: string, options?: SavingLedgerQueryOptions): Promise<SavingLedgerContract[]>;
+    getSavingBalanceByMember(memberId: string): Promise<SavingBalance>;
+}

package/dist/contracts/SavingLedgerContract.js

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

package/dist/contracts/SavingPolicyContract.d.ts

@@ -0,0 +1,63 @@
+export type FineType = 'fixed' | 'percentage';
+export interface SavingPolicyContract {
+    id: string;
+    koperasiId: string;
+    branchId?: string | null;
+    tenantId?: string | null;
+    simpananPokokNominalIdr: number;
+    monthlyWajibNominalIdr: number;
+    gracePeriodMonth: number;
+    dendaType: FineType;
+    dendaAmountIdr: number;
+    dendaPercentage: number;
+    warningAtMonths: number;
+    nonaktifAtMonths: number;
+    autoSetAnggotaNonaktif: boolean;
+    effectiveDate: string;
+    changeReason?: string | null;
+    approvalRef?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface SavingPolicyScope {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface UpsertSavingPolicyInput {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+    simpananPokokNominalIdr: number;
+    monthlyWajibNominalIdr: number;
+    gracePeriodMonth: number;
+    dendaType: FineType;
+    dendaAmountIdr: number;
+    dendaPercentage: number;
+    warningAtMonths: number;
+    nonaktifAtMonths: number;
+    autoSetAnggotaNonaktif: boolean;
+    effectiveDate: string;
+    changeReason?: string | null;
+    approvalRef?: string | null;
+}
+export interface SavingComplianceEvaluation {
+    summary: Record<string, number>;
+    referenceDate: string;
+}
+export interface SavingComplianceWorklistItem {
+    id: string;
+    memberId: string;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    reasonCode: string;
+    reasonText: string;
+    recommendedAction: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SavingPolicyServiceContract {
+    getActiveSavingPolicy(scope: SavingPolicyScope): Promise<SavingPolicyContract | null>;
+    upsertSavingPolicy(input: UpsertSavingPolicyInput): Promise<SavingPolicyContract>;
+    evaluateWajibCompliance(scope: SavingPolicyScope): Promise<SavingComplianceEvaluation>;
+    getComplianceWorklist(scope: SavingPolicyScope): Promise<SavingComplianceWorklistItem[]>;
+}

package/dist/contracts/SavingPolicyContract.js

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

package/dist/contracts/ShuConfigContract.d.ts

@@ -0,0 +1,39 @@
+export interface ShuConfigContract {
+    id: string;
+    koperasiId: string;
+    tenantId?: string | null;
+    branchId?: string | null;
+    effectiveDate: string;
+    cadanganPercent: number;
+    jasaUsahaPercent: number;
+    jasaModalPercent: number;
+    notes?: string | null;
+    approvalRef?: string | null;
+    version: number;
+    lastModified: string;
+    deleted: boolean;
+}
+export interface ShuConfigScope {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+}
+export interface UpsertShuConfigInput {
+    koperasiId: string;
+    tenantId: string;
+    branchId?: string | null;
+    effectiveDate: string;
+    cadanganPercent: number;
+    jasaUsahaPercent: number;
+    jasaModalPercent: number;
+    notes?: string | null;
+    approvalRef?: string | null;
+}
+export interface ShuConfigQueryOptions {
+    includeDeleted?: boolean;
+}
+export interface ShuConfigServiceContract {
+    getActiveShuConfig(scope: ShuConfigScope): Promise<ShuConfigContract | null>;
+    upsertShuConfig(input: UpsertShuConfigInput): Promise<ShuConfigContract>;
+    listShuConfigs(scope: ShuConfigScope, options?: ShuConfigQueryOptions): Promise<ShuConfigContract[]>;
+}

package/dist/contracts/ShuConfigContract.js

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