@degenerate/generic 0.2.7 → 0.4.0

package/dist/models/shareblock/shareblock-models.d.ts

@@ -0,0 +1,489 @@
+import z from 'zod';
+/**
+ * The four ShareBlock specializations the platform uses to move money
+ * through a loan's lifecycle.
+ *
+ *   - `Clearing`       — neutral holding spot funds pass through before they're
+ *                        committed to either side of a deal. Used to net
+ *                        borrower and lender flows before settling.
+ *   - `Funding`        — the lender-funded pool that backs a specific loan.
+ *                        Holds principal between funding and disbursement.
+ *   - `Distribution`   — the destination ShareBlock that pays principal to a
+ *                        borrower or returns/interest to a lender.
+ *   - `GraceRepayment` — the borrower-repayment block for Rapture's Grace
+ *                        product. Per-lender Grace-or-yield decisions are
+ *                        toggled while the loan is in flight, snapshotted at
+ *                        repayment-initiate, and drive the blended-rate
+ *                        allocation when the borrower pays. Terminal state is
+ *                        either `fullyRepaid: true` OR `defaulted: true`,
+ *                        mutually exclusive.
+ *
+ * New ShareBlock variants should be additive — never re-use a value with new
+ * semantics, since downstream rule libraries pattern-match on the literal.
+ */
+export declare enum ShareBlockType {
+    Clearing = "Clearing",
+    Funding = "Funding",
+    Distribution = "Distribution",
+    GraceRepayment = "GraceRepayment"
+}
+export declare const ShareBlockTypeSchema: z.ZodEnum<{
+    Clearing: "Clearing";
+    Funding: "Funding";
+    Distribution: "Distribution";
+    GraceRepayment: "GraceRepayment";
+}>;
+/**
+ * Roles a participant plays inside a ShareBlock. A single party may hold
+ * multiple roles across different ShareBlocks (e.g. the same uid is `Lender`
+ * on a Funding block and `Recipient` on a Distribution block).
+ */
+export declare enum ShareBlockParticipantRole {
+    Borrower = "Borrower",
+    Lender = "Lender",
+    Platform = "Platform",
+    Recipient = "Recipient"
+}
+export declare const ShareBlockParticipantRoleSchema: z.ZodEnum<{
+    Borrower: "Borrower";
+    Lender: "Lender";
+    Platform: "Platform";
+    Recipient: "Recipient";
+}>;
+/**
+ * A party in a ShareBlock with their associated role and committed amount.
+ * `committedAmount` is the headline contribution promised by the participant;
+ * `settledAmount` tracks how much has actually moved (so partial fills are
+ * representable). Both are in the ShareBlock's `currency`.
+ */
+export declare const IShareBlockParticipantSchema: z.ZodObject<{
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        Borrower: "Borrower";
+        Lender: "Lender";
+        Platform: "Platform";
+        Recipient: "Recipient";
+    }>;
+    committedAmount: z.ZodNumber;
+    settledAmount: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockParticipant = z.infer<typeof IShareBlockParticipantSchema>;
+/**
+ * The mutable state carried inside a ShareBlock's `_currentState`. This is
+ * the canonical shape rules and functions inspect when proposing changes.
+ *
+ *   - `balance` — funds currently held in the ShareBlock. Never negative.
+ *   - `currency` — ISO-4217 code (e.g. `'USD'`, `'CAD'`). Pinned at creation.
+ *   - `isOpen` — whether the ShareBlock will accept further transactions.
+ *                Closing is irreversible; once `false`, all standard rules
+ *                reject mutating proposals.
+ *   - `participants` — committed parties keyed by `userId`. Adding a
+ *                participant goes through a rule-gated function so the
+ *                participant list itself is auditable.
+ */
+export declare const IShareBlockStateSchema: z.ZodObject<{
+    blockType: z.ZodEnum<{
+        Clearing: "Clearing";
+        Funding: "Funding";
+        Distribution: "Distribution";
+        GraceRepayment: "GraceRepayment";
+    }>;
+    balance: z.ZodNumber;
+    currency: z.ZodString;
+    isOpen: z.ZodBoolean;
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            Borrower: "Borrower";
+            Lender: "Lender";
+            Platform: "Platform";
+            Recipient: "Recipient";
+        }>;
+        committedAmount: z.ZodNumber;
+        settledAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type IShareBlockState = z.infer<typeof IShareBlockStateSchema>;
+/**
+ * Funding-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `committed` — once `true`, the block's funds are locked: deposits and
+ *                   withdrawals become no-ops, and a "committed-is-monotonic"
+ *                   rule blocks any proposal that flips it back to `false`.
+ *   - `committedBy` / `committedAt` — audit attribution for the commit moment.
+ *
+ * Clearing ShareBlocks don't carry these fields; the discriminator is the
+ * `blockType` on the base state.
+ */
+export declare const IFundingShareBlockStateSchema: z.ZodObject<{
+    balance: z.ZodNumber;
+    currency: z.ZodString;
+    isOpen: z.ZodBoolean;
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            Borrower: "Borrower";
+            Lender: "Lender";
+            Platform: "Platform";
+            Recipient: "Recipient";
+        }>;
+        committedAmount: z.ZodNumber;
+        settledAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+    blockType: z.ZodLiteral<"Funding">;
+    committed: z.ZodBoolean;
+    committedBy: z.ZodOptional<z.ZodString>;
+    committedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type IFundingShareBlockState = z.infer<typeof IFundingShareBlockStateSchema>;
+/**
+ * Distribution-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `distributed` — once `true`, the block is fully paid out and further
+ *                     disbursements become no-ops. Enforced as monotonic by
+ *                     a dedicated rule (mirrors Funding's `committed`).
+ *   - `distributedAt` — audit attribution for the moment the block was
+ *                       marked fully distributed.
+ *
+ * Clearing ShareBlocks don't carry these fields; the discriminator is the
+ * `blockType` on the base state.
+ */
+export declare const IDistributionShareBlockStateSchema: z.ZodObject<{
+    balance: z.ZodNumber;
+    currency: z.ZodString;
+    isOpen: z.ZodBoolean;
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            Borrower: "Borrower";
+            Lender: "Lender";
+            Platform: "Platform";
+            Recipient: "Recipient";
+        }>;
+        committedAmount: z.ZodNumber;
+        settledAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+    blockType: z.ZodLiteral<"Distribution">;
+    distributed: z.ZodBoolean;
+    distributedBy: z.ZodOptional<z.ZodString>;
+    distributedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type IDistributionShareBlockState = z.infer<typeof IDistributionShareBlockStateSchema>;
+/**
+ * GraceRepayment-specific participant. Extends the base participant with
+ * three Grace-specific fields plus a denormalized ShareBlock count:
+ *
+ *   - `graceDecision`     — Lender-only field. The lender's current
+ *                            choice: take their yield, grant Grace, or
+ *                            undecided (the initial state when the
+ *                            GraceRepayment block is constructed).
+ *                            Borrower and Platform participants always
+ *                            carry `'undecided'` and never mutate it.
+ *   - `decidedAtMs`       — Unix-ms timestamp the lender last set their
+ *                            decision. `null` while undecided.
+ *   - `snapshotDecision`  — The locked-in decision at the moment the
+ *                            borrower initiated repayment. `null` until
+ *                            snapshot. After snapshot it's the
+ *                            authoritative value the per-lender
+ *                            settlement uses.
+ *   - `shareBlockCount`   — Derived count of $10 ShareBlocks held by
+ *                            this lender on this loan
+ *                            (`committedAmount / 1000` for cents-based
+ *                            committed amounts). Cached for fast UI
+ *                            queries; the canonical source is still
+ *                            `committedAmount`.
+ */
+export declare const IGraceRepaymentParticipantSchema: z.ZodObject<{
+    userId: z.ZodString;
+    role: z.ZodEnum<{
+        Borrower: "Borrower";
+        Lender: "Lender";
+        Platform: "Platform";
+        Recipient: "Recipient";
+    }>;
+    committedAmount: z.ZodNumber;
+    settledAmount: z.ZodNumber;
+    graceDecision: z.ZodEnum<{
+        yield: "yield";
+        grace: "grace";
+        undecided: "undecided";
+    }>;
+    decidedAtMs: z.ZodOptional<z.ZodNumber>;
+    snapshotDecision: z.ZodOptional<z.ZodEnum<{
+        yield: "yield";
+        grace: "grace";
+    }>>;
+    shareBlockCount: z.ZodNumber;
+}, z.core.$strip>;
+export type IGraceRepaymentParticipant = z.infer<typeof IGraceRepaymentParticipantSchema>;
+/**
+ * GraceRepayment-specific extension of `IShareBlockState`. Adds:
+ *
+ *   - `outstandingPrincipalCents`  — running principal balance the
+ *                                     borrower owes. Decrements as
+ *                                     repayments land.
+ *   - `outstandingInterestCents`   — interest owed at the time of
+ *                                     repayment snapshot. Computed
+ *                                     atomically at snapshot from the
+ *                                     blended rate; decrements as
+ *                                     repayments land.
+ *   - `repaymentSnapshotAtMs`      — unix-ms timestamp the per-lender
+ *                                     Grace decisions were locked in.
+ *                                     `null` until the borrower
+ *                                     initiates repayment.
+ *   - `blendedRatePercent`         — weighted-average effective rate
+ *                                     computed at snapshot. `null` pre-
+ *                                     snapshot.
+ *   - `finalEffectiveRatePercent`  — what the borrower actually pays;
+ *                                     equal to `blendedRatePercent`
+ *                                     under the standard formula. `null`
+ *                                     pre-snapshot.
+ *   - `fullyRepaid` / `defaulted`  — mutually exclusive terminal flags.
+ *                                     Both monotonic (once true, never
+ *                                     back to false).
+ *   - `defaultReason` / `defaultedAtMs` — audit attribution for the
+ *                                          default moment.
+ *
+ * Participants are typed as `IGraceRepaymentParticipant` (extended
+ * with per-lender Grace decision fields).
+ */
+export declare const IGraceRepaymentShareBlockStateSchema: z.ZodObject<{
+    balance: z.ZodNumber;
+    currency: z.ZodString;
+    isOpen: z.ZodBoolean;
+    blockType: z.ZodLiteral<"GraceRepayment">;
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            Borrower: "Borrower";
+            Lender: "Lender";
+            Platform: "Platform";
+            Recipient: "Recipient";
+        }>;
+        committedAmount: z.ZodNumber;
+        settledAmount: z.ZodNumber;
+        graceDecision: z.ZodEnum<{
+            yield: "yield";
+            grace: "grace";
+            undecided: "undecided";
+        }>;
+        decidedAtMs: z.ZodOptional<z.ZodNumber>;
+        snapshotDecision: z.ZodOptional<z.ZodEnum<{
+            yield: "yield";
+            grace: "grace";
+        }>>;
+        shareBlockCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    outstandingPrincipalCents: z.ZodNumber;
+    outstandingInterestCents: z.ZodNumber;
+    repaymentSnapshotAtMs: z.ZodOptional<z.ZodNumber>;
+    blendedRatePercent: z.ZodOptional<z.ZodNumber>;
+    finalEffectiveRatePercent: z.ZodOptional<z.ZodNumber>;
+    snapshotBaselineRatePercent: z.ZodOptional<z.ZodNumber>;
+    snapshotGraceMicroInterestPercent: z.ZodOptional<z.ZodNumber>;
+    snapshotGracePerShareBlockFeeCents: z.ZodOptional<z.ZodNumber>;
+    fullyRepaid: z.ZodBoolean;
+    defaulted: z.ZodBoolean;
+    defaultReason: z.ZodOptional<z.ZodString>;
+    defaultedAtMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type IGraceRepaymentShareBlockState = z.infer<typeof IGraceRepaymentShareBlockStateSchema>;
+/**
+ * Static information about a ShareBlock — set at construction and never
+ * mutated through transactions. Lives outside `IShareBlockState` because
+ * the rule-evaluation engine compares state shapes, and including identity
+ * metadata in that comparison would treat any new ShareBlock as a "change."
+ */
+export declare const IShareBlockMetadataSchema: z.ZodObject<{
+    shareBlockId: z.ZodString;
+    blockType: z.ZodEnum<{
+        Clearing: "Clearing";
+        Funding: "Funding";
+        Distribution: "Distribution";
+        GraceRepayment: "GraceRepayment";
+    }>;
+    relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    createdBy: z.ZodString;
+}, z.core.$strip>;
+export type IShareBlockMetadata = z.infer<typeof IShareBlockMetadataSchema>;
+/**
+ * Input shape every ShareBlock factory's `initialState` argument accepts.
+ * The factory layers the variant-specific defaults on top (`blockType`,
+ * `committed: false`, `distributed: false`, `isOpen: true`) — callers only
+ * supply the genuinely variant-agnostic fields.
+ *
+ * Used by the HTTP create route to validate the wire payload before
+ * dispatching to the matching factory.
+ */
+export declare const IShareBlockInitialStateInputSchema: z.ZodObject<{
+    currency: z.ZodString;
+    participants: z.ZodRecord<z.ZodString, z.ZodObject<{
+        userId: z.ZodString;
+        role: z.ZodEnum<{
+            Borrower: "Borrower";
+            Lender: "Lender";
+            Platform: "Platform";
+            Recipient: "Recipient";
+        }>;
+        committedAmount: z.ZodNumber;
+        settledAmount: z.ZodNumber;
+    }, z.core.$strip>>;
+    balance: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type IShareBlockInitialStateInput = z.infer<typeof IShareBlockInitialStateInputSchema>;
+/**
+ * Input shapes for the standard ShareBlock mutating functions. Each function
+ * the factory wires up takes one of these and proposes a new
+ * `IShareBlockState`. Rules judge the transition; the ShareData container
+ * applies it iff every rule passes.
+ */
+export declare const IShareBlockDepositInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockDepositInput = z.infer<typeof IShareBlockDepositInputSchema>;
+export declare const IShareBlockWithdrawInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockWithdrawInput = z.infer<typeof IShareBlockWithdrawInputSchema>;
+export declare const IShareBlockCloseInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export type IShareBlockCloseInput = z.infer<typeof IShareBlockCloseInputSchema>;
+/**
+ * Input for the Funding-specific `commit` function. Records who pulled the
+ * trigger on locking the funded amount; the function itself stamps
+ * `committedAt` from the system clock.
+ */
+export declare const IShareBlockCommitInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export type IShareBlockCommitInput = z.infer<typeof IShareBlockCommitInputSchema>;
+/**
+ * Input for the Funding-specific `registerLender` function. Adds a new
+ * `Lender`-role participant to the block so they can subsequently
+ * `deposit` (deposit gates on participant.role === Lender).
+ *
+ * The caller (Rapture's authenticated endpoint) is responsible for
+ * authorizing the registration — i.e. for confirming that `userId` is the
+ * authenticated user pledging on this loan. The shareblock layer just
+ * enforces structural invariants (no duplicate userId, positive
+ * committedAmount, block must be open and not committed).
+ */
+export declare const IShareBlockRegisterLenderInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    committedAmount: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockRegisterLenderInput = z.infer<typeof IShareBlockRegisterLenderInputSchema>;
+/**
+ * Input for the Distribution-specific `fund` function. Distinct from
+ * `IShareBlockDepositInput` only at the type level: keeps the wire shape
+ * narrow to "money coming in from another block" semantics rather than the
+ * general-purpose deposit on Clearing.
+ */
+export declare const IShareBlockFundInputSchema: z.ZodObject<{
+    fromBlockId: z.ZodOptional<z.ZodString>;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockFundInput = z.infer<typeof IShareBlockFundInputSchema>;
+/**
+ * Input for the Distribution-specific `disburse` function. `userId` must
+ * resolve to a participant with role `Recipient`, or the function no-ops.
+ */
+export declare const IShareBlockDisburseInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    amount: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockDisburseInput = z.infer<typeof IShareBlockDisburseInputSchema>;
+/**
+ * Input for the Distribution-specific `markFullyDistributed` function.
+ * Records who declared the block fully paid out; the function stamps
+ * `distributedAt`.
+ */
+export declare const IShareBlockMarkFullyDistributedInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export type IShareBlockMarkFullyDistributedInput = z.infer<typeof IShareBlockMarkFullyDistributedInputSchema>;
+/**
+ * Input for the GraceRepayment `setLenderGraceDecision` function.
+ * Lender-callable while the block is open and pre-snapshot. The block's
+ * rules also enforce that the calling userId matches the participant
+ * being mutated (lenders can only set their own decisions, not others').
+ */
+export declare const IShareBlockSetLenderGraceDecisionInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    decision: z.ZodEnum<{
+        yield: "yield";
+        grace: "grace";
+    }>;
+    decidedAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockSetLenderGraceDecisionInput = z.infer<typeof IShareBlockSetLenderGraceDecisionInputSchema>;
+/**
+ * Input for the GraceRepayment `snapshotForRepayment` function.
+ * Platform-only. Atomic: freezes every Lender participant's
+ * `snapshotDecision` from their current `graceDecision`, computes
+ * `blendedRatePercent` and `finalEffectiveRatePercent` from the
+ * weighted decisions, sets `outstandingInterestCents` to the final
+ * computed amount, and stamps `repaymentSnapshotAtMs`.
+ *
+ * `graceMicroInterestPercent` and `gracePerShareBlockFeeCents` are the
+ * platform-fee configuration values used in the math; passing them via
+ * the input keeps the variant function pure (no implicit config
+ * lookup).
+ */
+export declare const IShareBlockSnapshotForRepaymentInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    baselineRatePercent: z.ZodNumber;
+    termDays: z.ZodNumber;
+    graceMicroInterestPercent: z.ZodNumber;
+    gracePerShareBlockFeeCents: z.ZodNumber;
+    snapshotAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockSnapshotForRepaymentInput = z.infer<typeof IShareBlockSnapshotForRepaymentInputSchema>;
+/**
+ * Input for the GraceRepayment `recordRepayment` function. Platform-only.
+ * Applies an inbound borrower payment per the snapshot decisions:
+ * yield-ShareBlock lenders receive their share of `borrowerInterest`;
+ * grace-ShareBlock lenders receive only the micro-interest minus the
+ * per-ShareBlock fee. Decrements `outstandingInterestCents` first,
+ * then `outstandingPrincipalCents`. Auto-marks `fullyRepaid` when
+ * both reach zero.
+ *
+ * `paymentAttemptId` is the idempotency key — a second call with the
+ * same id is a no-op.
+ */
+export declare const IShareBlockRecordRepaymentInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    paymentAttemptId: z.ZodString;
+    amountCents: z.ZodNumber;
+    paidAtMs: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockRecordRepaymentInput = z.infer<typeof IShareBlockRecordRepaymentInputSchema>;
+/**
+ * Input for the GraceRepayment `markFullyRepaid` function. Platform-only.
+ * Asserts `outstandingPrincipalCents === 0 && outstandingInterestCents
+ * === 0` before flipping. Mutually exclusive with `markDefaulted`.
+ */
+export declare const IShareBlockMarkFullyRepaidInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    asOf: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockMarkFullyRepaidInput = z.infer<typeof IShareBlockMarkFullyRepaidInputSchema>;
+/**
+ * Input for the GraceRepayment `markDefaulted` function. Platform-only.
+ * Mutually exclusive with `markFullyRepaid`. Sets the terminal default
+ * flag + audit metadata; the post-default flow (lender write-off,
+ * borrower loyalty reset, identity-reveal opt-ins) happens in Rapture's
+ * trigger layer, not here.
+ */
+export declare const IShareBlockMarkDefaultedInputSchema: z.ZodObject<{
+    userId: z.ZodString;
+    reason: z.ZodString;
+    asOf: z.ZodNumber;
+}, z.core.$strip>;
+export type IShareBlockMarkDefaultedInput = z.infer<typeof IShareBlockMarkDefaultedInputSchema>;
+//# sourceMappingURL=shareblock-models.d.ts.map

package/dist/models/shareblock/shareblock-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shareblock-models.d.ts","sourceRoot":"","sources":["../../../src/models/shareblock/shareblock-models.ts"],"names":[],"mappings":"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"}