@degenerate/generic 0.2.6 → 0.3.2

package/dist/models/share-data/share-data-persistence-models.d.ts

@@ -0,0 +1,158 @@
+import z from 'zod';
+import { EllipticalCurvesSigning } from '../../_settings/cryptography-settings';
+import { ShareBlockType } from '../shareblock/shareblock-models';
+/**
+ * The signing curve a persisted block was created with. Mirrors the values of
+ * {@link EllipticalCurvesSigning}; stored for forward-compatibility even
+ * though every shipped factory currently uses the `Curve25519` default.
+ */
+export declare const PersistedSigningCurveSchema: z.ZodEnum<{
+    ed25519: EllipticalCurvesSigning.Curve25519;
+    p521: EllipticalCurvesSigning.P521;
+}>;
+/**
+ * The factory creation input needed to replay construction, minus the
+ * `proofFor` callback (which is reconstructed from the stored
+ * `structuralProofs` + `initialCrypto` at load time). `initialState` is the
+ * *partial* state the factory was given — the factory deterministically
+ * assembles the full state from it, so storing the partial form is both
+ * sufficient and forward-stable.
+ */
+export declare const PersistedCreationConfigSchema: z.ZodObject<{
+    metadata: z.ZodObject<{
+        shareBlockId: z.ZodString;
+        blockType: z.ZodEnum<{
+            Clearing: "Clearing";
+            Funding: "Funding";
+            Distribution: "Distribution";
+        }>;
+        relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        createdBy: z.ZodString;
+    }, z.core.$strip>;
+    creationPublicKey: z.ZodString;
+    initialState: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+export type PersistedCreationConfig = z.infer<typeof PersistedCreationConfigSchema>;
+/**
+ * The two facts a {@link ShareDataManager} must retain about a block to keep
+ * persisting it after creation: which factory built it and the creation input
+ * that factory was given. A live block retains neither — `serializeShareData`
+ * needs both supplied — so the manager captures them at `addShareData` time and
+ * carries them alongside the accumulating transaction log for every subsequent
+ * write-through. Supplied by the caller that created the block (e.g. the HTTP
+ * create route).
+ */
+export interface ShareDataCreationRecord {
+    blockType: ShareBlockType;
+    creationConfig: PersistedCreationConfig;
+}
+/**
+ * One post-creation transaction, captured at apply time. The live
+ * `transactionHistory` does NOT retain a transaction's input or proposed
+ * state, so these must be recorded when the transaction is applied rather
+ * than recovered from a finished block.
+ *
+ *   - `functionId` re-resolves the live function on the rebuilt block (same
+ *     id-based lookup `createIdBasedFunctionResolver` uses).
+ *   - `proposedState` is the state written when the transaction was accepted;
+ *     it is what replay re-applies.
+ *   - `proof` is the transaction proposal proof that authorized the change. It
+ *     is re-verified against the rebuilt block + `proposedState` during replay,
+ *     so a snapshot whose proposed state or proof was edited fails the load.
+ *     Recording it also keeps the rebuilt block byte-faithful: the live history
+ *     entry carries its proof, and the canonical share-data hash folds the
+ *     history in, so replay must reproduce the proof to hash identically.
+ *   - `transactionTime` is stored so the replayed history hashes identically.
+ *   - `ruleOutcome` records whether the original proposal was accepted.
+ */
+export declare const PersistedTransactionSchema: z.ZodObject<{
+    functionId: z.ZodString;
+    input: z.ZodOptional<z.ZodAny>;
+    proposedState: z.ZodRecord<z.ZodString, z.ZodAny>;
+    proof: z.ZodObject<{
+        publicKey: z.ZodString;
+        shareDataHash: z.ZodString;
+        shareDataPreviousHash: z.ZodString;
+        shareDataSignature: z.ZodString;
+        timestamp: z.ZodNumber;
+        purpose: z.ZodString;
+    }, z.core.$strip>;
+    transactionTime: z.ZodNumber;
+    ruleOutcome: z.ZodBoolean;
+}, z.core.$strip>;
+export type PersistedTransaction = z.infer<typeof PersistedTransactionSchema>;
+/**
+ * A durable snapshot of a ShareData. Versioned via `schemaVersion` so a future
+ * format change can be gated cleanly. The `expected*` fields are NOT trusted
+ * on load — they are cross-checked against the independently replayed block so
+ * a snapshot whose state was edited without re-signing fails loudly.
+ */
+export declare const PersistedShareDataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    id: z.ZodString;
+    blockType: z.ZodEnum<{
+        Clearing: "Clearing";
+        Funding: "Funding";
+        Distribution: "Distribution";
+    }>;
+    signingCurve: z.ZodEnum<{
+        ed25519: EllipticalCurvesSigning.Curve25519;
+        p521: EllipticalCurvesSigning.P521;
+    }>;
+    initialCrypto: z.ZodObject<{
+        publicKey: z.ZodString;
+        shareDataHash: z.ZodString;
+        shareDataSignature: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>;
+    creationConfig: z.ZodObject<{
+        metadata: z.ZodObject<{
+            shareBlockId: z.ZodString;
+            blockType: z.ZodEnum<{
+                Clearing: "Clearing";
+                Funding: "Funding";
+                Distribution: "Distribution";
+            }>;
+            relatedLoanApplicationId: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+            createdBy: z.ZodString;
+        }, z.core.$strip>;
+        creationPublicKey: z.ZodString;
+        initialState: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, z.core.$strip>;
+    structuralProofs: z.ZodRecord<z.ZodString, z.ZodObject<{
+        publicKey: z.ZodString;
+        shareDataHash: z.ZodString;
+        shareDataPreviousHash: z.ZodString;
+        shareDataSignature: z.ZodString;
+        timestamp: z.ZodNumber;
+        purpose: z.ZodString;
+    }, z.core.$strip>>;
+    transactionLog: z.ZodArray<z.ZodObject<{
+        functionId: z.ZodString;
+        input: z.ZodOptional<z.ZodAny>;
+        proposedState: z.ZodRecord<z.ZodString, z.ZodAny>;
+        proof: z.ZodObject<{
+            publicKey: z.ZodString;
+            shareDataHash: z.ZodString;
+            shareDataPreviousHash: z.ZodString;
+            shareDataSignature: z.ZodString;
+            timestamp: z.ZodNumber;
+            purpose: z.ZodString;
+        }, z.core.$strip>;
+        transactionTime: z.ZodNumber;
+        ruleOutcome: z.ZodBoolean;
+    }, z.core.$strip>>;
+    expectedCurrentState: z.ZodRecord<z.ZodString, z.ZodAny>;
+    expectedCreationHash: z.ZodString;
+    expectedCreationSignature: z.ZodString;
+    expectedIsLocked: z.ZodBoolean;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type PersistedShareData = z.infer<typeof PersistedShareDataSchema>;
+/** The only schema version this build understands. */
+export declare const PERSISTED_SHARE_DATA_SCHEMA_VERSION: 2;
+//# sourceMappingURL=share-data-persistence-models.d.ts.map

package/dist/models/share-data/share-data-persistence-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-data-persistence-models.d.ts","sourceRoot":"","sources":["../../../src/models/share-data/share-data-persistence-models.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AACpB,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAEH,cAAc,EAEjB,MAAM,iCAAiC,CAAC;AAkBzC;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;EAGtC,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;iBAIxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACpC,SAAS,EAAE,cAAc,CAAC;IAC1B,cAAc,EAAE,uBAAuB,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;iBAOrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgBnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,sDAAsD;AACtD,eAAO,MAAM,mCAAmC,EAAG,CAAU,CAAC"}

package/dist/models/share-data/share-data-persistence-models.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERSISTED_SHARE_DATA_SCHEMA_VERSION = exports.PersistedShareDataSchema = exports.PersistedTransactionSchema = exports.PersistedCreationConfigSchema = exports.PersistedSigningCurveSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const cryptography_settings_1 = require("../../_settings/cryptography-settings");
+const shareblock_models_1 = require("../shareblock/shareblock-models");
+const share_data_crypto_models_1 = require("./share-data-crypto-models");
+const share_data_models_1 = require("./share-data-models");
+// This file contains the wire-format models for persisting a ShareData to a
+// durable store and reconstructing it. The design is event-sourced: a
+// snapshot stores the *creation recipe* + an ordered transaction log, not a
+// field-dump of a finished object. Reload replays construction (re-verifying
+// the structural-proof chain) and the transaction log, then cross-checks the
+// result against the stored `expected*` integrity values. See
+// `plans/PERSISTENCE_PLAN.html`.
+//#region Persistence Schemas
+/**
+ * The signing curve a persisted block was created with. Mirrors the values of
+ * {@link EllipticalCurvesSigning}; stored for forward-compatibility even
+ * though every shipped factory currently uses the `Curve25519` default.
+ */
+exports.PersistedSigningCurveSchema = zod_1.default.enum([
+    cryptography_settings_1.EllipticalCurvesSigning.Curve25519,
+    cryptography_settings_1.EllipticalCurvesSigning.P521,
+]);
+/**
+ * The factory creation input needed to replay construction, minus the
+ * `proofFor` callback (which is reconstructed from the stored
+ * `structuralProofs` + `initialCrypto` at load time). `initialState` is the
+ * *partial* state the factory was given — the factory deterministically
+ * assembles the full state from it, so storing the partial form is both
+ * sufficient and forward-stable.
+ */
+exports.PersistedCreationConfigSchema = zod_1.default.object({
+    metadata: shareblock_models_1.IShareBlockMetadataSchema,
+    creationPublicKey: zod_1.default.string(),
+    initialState: zod_1.default.record(zod_1.default.string(), zod_1.default.any()),
+});
+/**
+ * One post-creation transaction, captured at apply time. The live
+ * `transactionHistory` does NOT retain a transaction's input or proposed
+ * state, so these must be recorded when the transaction is applied rather
+ * than recovered from a finished block.
+ *
+ *   - `functionId` re-resolves the live function on the rebuilt block (same
+ *     id-based lookup `createIdBasedFunctionResolver` uses).
+ *   - `proposedState` is the state written when the transaction was accepted;
+ *     it is what replay re-applies.
+ *   - `proof` is the transaction proposal proof that authorized the change. It
+ *     is re-verified against the rebuilt block + `proposedState` during replay,
+ *     so a snapshot whose proposed state or proof was edited fails the load.
+ *     Recording it also keeps the rebuilt block byte-faithful: the live history
+ *     entry carries its proof, and the canonical share-data hash folds the
+ *     history in, so replay must reproduce the proof to hash identically.
+ *   - `transactionTime` is stored so the replayed history hashes identically.
+ *   - `ruleOutcome` records whether the original proposal was accepted.
+ */
+exports.PersistedTransactionSchema = zod_1.default.object({
+    functionId: zod_1.default.string(),
+    input: zod_1.default.any().optional(),
+    proposedState: share_data_models_1.IShareDataSchema,
+    proof: share_data_crypto_models_1.IShareDataCryptoProofSchema,
+    transactionTime: zod_1.default.number(),
+    ruleOutcome: zod_1.default.boolean(),
+});
+/**
+ * A durable snapshot of a ShareData. Versioned via `schemaVersion` so a future
+ * format change can be gated cleanly. The `expected*` fields are NOT trusted
+ * on load — they are cross-checked against the independently replayed block so
+ * a snapshot whose state was edited without re-signing fails loudly.
+ */
+exports.PersistedShareDataSchema = zod_1.default.object({
+    schemaVersion: zod_1.default.literal(2),
+    id: zod_1.default.string(),
+    blockType: shareblock_models_1.ShareBlockTypeSchema,
+    signingCurve: exports.PersistedSigningCurveSchema,
+    initialCrypto: share_data_crypto_models_1.IShareDataInitialCryptoDataSchema,
+    creationConfig: exports.PersistedCreationConfigSchema,
+    structuralProofs: share_data_crypto_models_1.ShareDataProofsSchema,
+    transactionLog: zod_1.default.array(exports.PersistedTransactionSchema),
+    // Integrity cross-checks — compared against the replayed result, never
+    // trusted as source of truth.
+    expectedCurrentState: share_data_models_1.IShareDataSchema,
+    expectedCreationHash: zod_1.default.string(),
+    expectedCreationSignature: zod_1.default.string(),
+    expectedIsLocked: zod_1.default.boolean(),
+    expectedVersion: zod_1.default.number(),
+});
+/** The only schema version this build understands. */
+exports.PERSISTED_SHARE_DATA_SCHEMA_VERSION = 2;
+//#endregion Persistence Schemas

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

@@ -0,0 +1,280 @@
+import z from 'zod';
+/**
+ * The three 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.
+ *
+ * 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"
+}
+export declare const ShareBlockTypeSchema: z.ZodEnum<{
+    Clearing: "Clearing";
+    Funding: "Funding";
+    Distribution: "Distribution";
+}>;
+/**
+ * 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";
+    }>;
+    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>;
+/**
+ * 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";
+    }>;
+    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>;
+//# 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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"}