@hazbase/simplicity 0.0.5 → 0.1.1

package/dist/domain/fund.d.ts

@@ -0,0 +1,2069 @@
+import type { SimplicityClient } from "../client/SimplicityClient";
+import type { BondOutputBindingMode, CapitalCallState, DistributionDescriptor, FundClosingDescriptor, FundDefinition, FundEvidenceBundle, FundFinalityPayload, FundPayoutDescriptor, FundVerificationReport, FundVerificationReportSchemaVersion, LPPositionReceipt, LPPositionReceiptEnvelope, OutputAmountForm, OutputAssetForm, OutputBindingInputs, OutputBindingReasonCode, OutputBindingSupportedForm, OutputNonceForm, OutputRawFields, OutputRangeProofForm, SimplicityArtifact } from "../core/types";
+export declare function define(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+}): Promise<{
+    ok: boolean;
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    summary: {
+        canonicalJson: string;
+        hash: string;
+    };
+}>;
+export declare function verify(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+}): Promise<{
+    ok: boolean;
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    summary: {
+        canonicalJson: string;
+        hash: string;
+    };
+}>;
+export declare function load(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+}): Promise<{
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    summary: {
+        canonicalJson: string;
+        hash: string;
+    };
+}>;
+export declare function prepareCapitalCall(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    capitalCallPath?: string;
+    capitalCallValue?: CapitalCallState;
+    openSimfPath?: string;
+    refundOnlySimfPath?: string;
+    openArtifactPath?: string;
+    refundOnlyArtifactPath?: string;
+}): Promise<{
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    capitalCall: import("../core/types").StateDocumentDescriptor;
+    capitalCallValue: CapitalCallState;
+    capitalCallSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    refundOnlyCapitalCallValue: CapitalCallState;
+    refundOnlyCapitalCallSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    crossChecks: {
+        fundIdMatch: boolean;
+        currencyMatch: boolean;
+        managerMatch: boolean;
+    };
+    openCompiled: import("..").CompiledContract;
+    refundOnlyCompiled: import("..").CompiledContract;
+    report: {
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: true;
+            lpCommitted: true;
+            managerCommitted: true;
+            claimPathRuntimeAvailable: true;
+            refundPathRuntimeAvailable: false;
+            statusValid: true;
+        };
+        schemaVersion: FundVerificationReportSchemaVersion;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        receiptTrust?: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function verifyCapitalCall(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    capitalCallPath?: string;
+    capitalCallValue?: CapitalCallState;
+}): Promise<{
+    ok: boolean;
+    reason: string | undefined;
+    artifact: SimplicityArtifact | undefined;
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    capitalCall: import("../core/types").StateDocumentDescriptor;
+    capitalCallValue: CapitalCallState;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    capitalCallSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    artifactVerification: {
+        definition: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+    } | undefined;
+    report: {
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        receiptTrust?: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function signPositionReceipt(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceipt;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    signedAt?: string;
+}): Promise<{
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceipt;
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelope: LPPositionReceiptEnvelope;
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+}>;
+export declare function verifyPositionReceipt(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+}): Promise<{
+    verified: boolean;
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceiptEnvelope;
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    receiptChecks: {
+        positionReceiptHashMatch: boolean;
+        sequenceMatch: boolean;
+        sequenceMonotonic: boolean;
+        attestingSignerMatch: boolean;
+        attestationVerified: boolean;
+    };
+    report: {
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        schemaVersion: FundVerificationReportSchemaVersion;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function inspectCapitalCallClaim(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    capitalCallPath?: string;
+    capitalCallValue?: CapitalCallState;
+    payoutAddress: string;
+    positionId?: string;
+    claimedAt?: string;
+    nextOutputHash?: string;
+    outputForm?: {
+        assetForm?: OutputAssetForm;
+        amountForm?: OutputAmountForm;
+        nonceForm?: OutputNonceForm;
+        rangeProofForm?: OutputRangeProofForm;
+    };
+    rawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+    wallet: string;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    feeSat?: number;
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "claim";
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        capitalCall: import("../core/types").StateDocumentDescriptor;
+        capitalCallValue: CapitalCallState;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        capitalCallSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            capitalCallTrust: {
+                capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+                cutoffMode: "rollover-window";
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: true;
+            };
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            distributionTrust?: {
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+                positionStatusEligible: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            receiptTrust?: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    payoutDescriptor: FundPayoutDescriptor;
+    payoutSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    claimedCapitalCall: CapitalCallState;
+    positionReceipt: LPPositionReceipt;
+    positionReceiptEnvelope: LPPositionReceiptEnvelope;
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    inspect: import("../core/types").InspectResult;
+    report: {
+        outputBindingTrust: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        } | undefined;
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function executeCapitalCallClaim(sdk: SimplicityClient, input: Parameters<typeof inspectCapitalCallClaim>[1] & {
+    broadcast?: boolean;
+}): Promise<{
+    mode: "claim";
+    execution: import("../core/types").ExecuteResult;
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        capitalCall: import("../core/types").StateDocumentDescriptor;
+        capitalCallValue: CapitalCallState;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        capitalCallSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            capitalCallTrust: {
+                capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+                cutoffMode: "rollover-window";
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: true;
+            };
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            distributionTrust?: {
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+                positionStatusEligible: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            receiptTrust?: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    payoutDescriptor: FundPayoutDescriptor;
+    payoutSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    claimedCapitalCall: CapitalCallState;
+    positionReceipt: LPPositionReceipt;
+    positionReceiptEnvelope: LPPositionReceiptEnvelope;
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    inspect: import("../core/types").InspectResult;
+    report: {
+        outputBindingTrust: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        } | undefined;
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function inspectCapitalCallRollover(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    refundOnlyArtifactPath?: string;
+    refundOnlyArtifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    capitalCallPath?: string;
+    capitalCallValue?: CapitalCallState;
+    wallet: string;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    feeSat?: number;
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "rollover";
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        capitalCall: import("../core/types").StateDocumentDescriptor;
+        capitalCallValue: CapitalCallState;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        capitalCallSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            capitalCallTrust: {
+                capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+                cutoffMode: "rollover-window";
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: true;
+            };
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            distributionTrust?: {
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+                positionStatusEligible: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            receiptTrust?: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    refundOnlyArtifact: SimplicityArtifact;
+    rolledOverCapitalCall: CapitalCallState;
+    inspect: import("../core/types").InspectResult;
+    report: {
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        receiptTrust?: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function executeCapitalCallRollover(sdk: SimplicityClient, input: Parameters<typeof inspectCapitalCallRollover>[1] & {
+    broadcast?: boolean;
+}): Promise<{
+    mode: "rollover";
+    execution: import("../core/types").ExecuteResult;
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        capitalCall: import("../core/types").StateDocumentDescriptor;
+        capitalCallValue: CapitalCallState;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        capitalCallSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            capitalCallTrust: {
+                capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+                cutoffMode: "rollover-window";
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: true;
+            };
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            distributionTrust?: {
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+                positionStatusEligible: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            receiptTrust?: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    refundOnlyArtifact: SimplicityArtifact;
+    rolledOverCapitalCall: CapitalCallState;
+    inspect: import("../core/types").InspectResult;
+    report: {
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        receiptTrust?: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function inspectCapitalCallRefund(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    capitalCallPath?: string;
+    capitalCallValue?: CapitalCallState;
+    refundAddress: string;
+    refundedAt?: string;
+    wallet: string;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    feeSat?: number;
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "refund";
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        capitalCall: import("../core/types").StateDocumentDescriptor;
+        capitalCallValue: CapitalCallState;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        capitalCallSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            capitalCallTrust: {
+                capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+                cutoffMode: "rollover-window";
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: true;
+            };
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            distributionTrust?: {
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+                positionStatusEligible: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            receiptTrust?: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    refundedCapitalCall: CapitalCallState;
+    inspect: import("../core/types").InspectResult;
+    report: {
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        receiptTrust?: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function executeCapitalCallRefund(sdk: SimplicityClient, input: Parameters<typeof inspectCapitalCallRefund>[1] & {
+    broadcast?: boolean;
+}): Promise<{
+    mode: "refund";
+    execution: import("../core/types").ExecuteResult;
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        capitalCall: import("../core/types").StateDocumentDescriptor;
+        capitalCallValue: CapitalCallState;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        capitalCallSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            capitalCallTrust: {
+                capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+                cutoffMode: "rollover-window";
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: true;
+            };
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            distributionTrust?: {
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+                positionStatusEligible: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            receiptTrust?: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    refundedCapitalCall: CapitalCallState;
+    inspect: import("../core/types").InspectResult;
+    report: {
+        capitalCallTrust: {
+            capitalCallStage: "open" | "claimed" | "refund-only" | "refunded";
+            cutoffMode: "rollover-window";
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: true;
+        };
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        receiptTrust?: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function prepareDistribution(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    distributionPath?: string;
+    distributionValue?: DistributionDescriptor;
+    distributionId?: string;
+    assetId?: string;
+    amountSat?: number;
+    approvedAt?: string;
+    simfPath?: string;
+    artifactPath?: string;
+}): Promise<{
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceiptEnvelope;
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    distribution: import("../core/types").StateDocumentDescriptor;
+    distributionValue: DistributionDescriptor;
+    distributionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    crossChecks: {
+        fundIdMatch: boolean;
+        lpIdMatch: boolean;
+        positionIdMatch: boolean;
+        positionReceiptHashMatch: boolean;
+        positionStatusEligible: boolean;
+    };
+    compiled: import("..").CompiledContract;
+    report: {
+        distributionTrust: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        schemaVersion: FundVerificationReportSchemaVersion;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function reconcilePosition(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    distributionPath?: string;
+    distributionValue?: DistributionDescriptor;
+    distributionPaths?: string[];
+    distributionValues?: DistributionDescriptor[];
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    signedAt?: string;
+}): Promise<{
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceiptEnvelope;
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    distributions: import("../core/types").StateDocumentDescriptor[];
+    distributionValues: DistributionDescriptor[];
+    distributionSummaries: {
+        canonicalJson: string;
+        hash: string;
+    }[];
+    reconciledReceiptValue: LPPositionReceipt;
+    reconciledReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    reconciledReceiptEnvelope: LPPositionReceiptEnvelope;
+    reconciledReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    totalDistributedAmount: number;
+    distributionCount: number;
+}>;
+export declare function verifyDistribution(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    distributionPath?: string;
+    distributionValue?: DistributionDescriptor;
+}): Promise<{
+    ok: boolean;
+    reason: string | undefined;
+    artifact: SimplicityArtifact | undefined;
+    definition: import("../core/types").DefinitionDescriptor;
+    definitionValue: FundDefinition;
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceiptEnvelope;
+    distribution: import("../core/types").StateDocumentDescriptor;
+    distributionValue: DistributionDescriptor;
+    definitionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    distributionSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    artifactVerification: {
+        definition: import("../core/types").DefinitionVerificationResult;
+        state: import("../core/types").StateVerificationResult;
+    } | undefined;
+    report: {
+        distributionTrust: {
+            positionStatusEligible: boolean;
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+        };
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function inspectDistributionClaim(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    distributionPath?: string;
+    distributionValue?: DistributionDescriptor;
+    payoutAddress: string;
+    nextOutputHash?: string;
+    outputForm?: {
+        assetForm?: OutputAssetForm;
+        amountForm?: OutputAmountForm;
+        nonceForm?: OutputNonceForm;
+        rangeProofForm?: OutputRangeProofForm;
+    };
+    rawOutput?: Partial<OutputRawFields>;
+    outputBindingMode?: BondOutputBindingMode;
+    wallet: string;
+    signer: {
+        type: "schnorrPrivkeyHex";
+        privkeyHex: string;
+    };
+    feeSat?: number;
+    utxoPolicy?: "smallest_over" | "largest" | "newest";
+}): Promise<{
+    mode: "distribution-claim";
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        positionReceipt: import("../core/types").StateDocumentDescriptor;
+        positionReceiptValue: LPPositionReceiptEnvelope;
+        distribution: import("../core/types").StateDocumentDescriptor;
+        distributionValue: DistributionDescriptor;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        positionReceiptSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        positionReceiptEnvelopeSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        distributionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            distributionTrust: {
+                positionStatusEligible: boolean;
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+            };
+            receiptTrust: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            } | undefined;
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            capitalCallTrust?: {
+                capitalCallStage: import("../core/types").CapitalCallStage;
+                cutoffMode: import("../core/types").CapitalCallCutoffMode;
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    payoutDescriptor: FundPayoutDescriptor;
+    payoutSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    inspect: import("../core/types").InspectResult;
+    report: {
+        outputBindingTrust: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        } | undefined;
+        distributionTrust: {
+            positionStatusEligible: boolean;
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+        };
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function executeDistributionClaim(sdk: SimplicityClient, input: Parameters<typeof inspectDistributionClaim>[1] & {
+    broadcast?: boolean;
+}): Promise<{
+    mode: "distribution-claim";
+    execution: import("../core/types").ExecuteResult;
+    verified: {
+        ok: boolean;
+        reason: string | undefined;
+        artifact: SimplicityArtifact | undefined;
+        definition: import("../core/types").DefinitionDescriptor;
+        definitionValue: FundDefinition;
+        positionReceipt: import("../core/types").StateDocumentDescriptor;
+        positionReceiptValue: LPPositionReceiptEnvelope;
+        distribution: import("../core/types").StateDocumentDescriptor;
+        distributionValue: DistributionDescriptor;
+        definitionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        positionReceiptSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        positionReceiptEnvelopeSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        distributionSummary: {
+            canonicalJson: string;
+            hash: string;
+        };
+        artifactVerification: {
+            definition: import("../core/types").DefinitionVerificationResult;
+            state: import("../core/types").StateVerificationResult;
+        } | undefined;
+        report: {
+            distributionTrust: {
+                positionStatusEligible: boolean;
+                fundIdMatch: boolean;
+                lpIdMatch: boolean;
+                positionIdMatch: boolean;
+                positionReceiptHashMatch: boolean;
+            };
+            receiptTrust: {
+                generated: boolean;
+                positionReceiptHash?: string;
+                positionStatus: import("../core/types").LPPositionReceiptStatus;
+                attested: boolean;
+                attestationVerified: boolean;
+                sequence?: number;
+                sequenceMonotonic?: boolean;
+                attestingSignerMatch?: boolean;
+            } | undefined;
+            artifactTrust?: {
+                definition: import("../core/types").DefinitionVerificationResult["trust"];
+                state: import("../core/types").StateVerificationResult["trust"];
+            };
+            stateTrust?: import("../core/types").StateVerificationResult["trust"];
+            schemaVersion: FundVerificationReportSchemaVersion;
+            capitalCallTrust?: {
+                capitalCallStage: import("../core/types").CapitalCallStage;
+                cutoffMode: import("../core/types").CapitalCallCutoffMode;
+                fundIdMatch: boolean;
+                currencyMatch: boolean;
+                managerMatch: boolean;
+                claimCutoffCommitted: boolean;
+                lpCommitted: boolean;
+                managerCommitted: boolean;
+                claimPathRuntimeAvailable: boolean;
+                refundPathRuntimeAvailable: boolean;
+                statusValid: boolean;
+            };
+            outputBindingTrust?: {
+                mode: BondOutputBindingMode;
+                requestedMode?: BondOutputBindingMode;
+                supportedForm?: OutputBindingSupportedForm;
+                nextReceiverRuntimeCommitted: boolean;
+                outputCountRuntimeBound: boolean;
+                feeIndexRuntimeBound: boolean;
+                nextOutputHashRuntimeBound?: boolean;
+                nextOutputScriptRuntimeBound: boolean;
+                amountRuntimeBound: boolean;
+                reasonCode?: OutputBindingReasonCode;
+                autoDerived?: boolean;
+                fallbackReason?: string;
+                bindingInputs?: OutputBindingInputs;
+            };
+            closingTrust?: {
+                positionReceiptHashMatch: boolean;
+                finalDistributionHashesPresent: boolean;
+                positionStatusEligible: boolean;
+            };
+        };
+    };
+    payoutDescriptor: FundPayoutDescriptor;
+    payoutSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    inspect: import("../core/types").InspectResult;
+    report: {
+        outputBindingTrust: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        } | undefined;
+        distributionTrust: {
+            positionStatusEligible: boolean;
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+        };
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        schemaVersion: FundVerificationReportSchemaVersion;
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        closingTrust?: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+    };
+}>;
+export declare function prepareClosing(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    closingPath?: string;
+    closingValue?: FundClosingDescriptor;
+    closingId?: string;
+    finalDistributionHashes?: string[];
+    closedAt?: string;
+    closingReason?: FundClosingDescriptor["closingReason"];
+}): Promise<{
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceiptEnvelope;
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    closing: import("../core/types").StateDocumentDescriptor;
+    closingValue: FundClosingDescriptor;
+    closingSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    closingHash: string;
+    checks: {
+        positionReceiptHashMatch: boolean;
+        finalDistributionHashesPresent: boolean;
+        positionStatusEligible: boolean;
+    };
+    report: {
+        closingTrust: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        schemaVersion: FundVerificationReportSchemaVersion;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+    };
+}>;
+export declare function verifyClosing(sdk: SimplicityClient, input: {
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    closingPath?: string;
+    closingValue?: FundClosingDescriptor;
+}): Promise<{
+    verified: boolean;
+    positionReceipt: import("../core/types").StateDocumentDescriptor;
+    positionReceiptValue: LPPositionReceiptEnvelope;
+    positionReceiptSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    positionReceiptEnvelopeSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    closing: import("../core/types").StateDocumentDescriptor;
+    closingValue: FundClosingDescriptor;
+    closingSummary: {
+        canonicalJson: string;
+        hash: string;
+    };
+    checks: {
+        positionReceiptHashMatch: boolean;
+        finalDistributionHashesPresent: boolean;
+        positionStatusEligible: boolean;
+    };
+    report: {
+        closingTrust: {
+            positionReceiptHashMatch: boolean;
+            finalDistributionHashesPresent: boolean;
+            positionStatusEligible: boolean;
+        };
+        receiptTrust: {
+            generated: boolean;
+            positionReceiptHash?: string;
+            positionStatus: import("../core/types").LPPositionReceiptStatus;
+            attested: boolean;
+            attestationVerified: boolean;
+            sequence?: number;
+            sequenceMonotonic?: boolean;
+            attestingSignerMatch?: boolean;
+        } | undefined;
+        schemaVersion: FundVerificationReportSchemaVersion;
+        artifactTrust?: {
+            definition: import("../core/types").DefinitionVerificationResult["trust"];
+            state: import("../core/types").StateVerificationResult["trust"];
+        };
+        stateTrust?: import("../core/types").StateVerificationResult["trust"];
+        capitalCallTrust?: {
+            capitalCallStage: import("../core/types").CapitalCallStage;
+            cutoffMode: import("../core/types").CapitalCallCutoffMode;
+            fundIdMatch: boolean;
+            currencyMatch: boolean;
+            managerMatch: boolean;
+            claimCutoffCommitted: boolean;
+            lpCommitted: boolean;
+            managerCommitted: boolean;
+            claimPathRuntimeAvailable: boolean;
+            refundPathRuntimeAvailable: boolean;
+            statusValid: boolean;
+        };
+        distributionTrust?: {
+            fundIdMatch: boolean;
+            lpIdMatch: boolean;
+            positionIdMatch: boolean;
+            positionReceiptHashMatch: boolean;
+            positionStatusEligible: boolean;
+        };
+        outputBindingTrust?: {
+            mode: BondOutputBindingMode;
+            requestedMode?: BondOutputBindingMode;
+            supportedForm?: OutputBindingSupportedForm;
+            nextReceiverRuntimeCommitted: boolean;
+            outputCountRuntimeBound: boolean;
+            feeIndexRuntimeBound: boolean;
+            nextOutputHashRuntimeBound?: boolean;
+            nextOutputScriptRuntimeBound: boolean;
+            amountRuntimeBound: boolean;
+            reasonCode?: OutputBindingReasonCode;
+            autoDerived?: boolean;
+            fallbackReason?: string;
+            bindingInputs?: OutputBindingInputs;
+        };
+    };
+}>;
+export declare function exportEvidence(sdk: SimplicityClient, input: {
+    artifactPath?: string;
+    artifact?: SimplicityArtifact;
+    definitionPath?: string;
+    definitionValue?: FundDefinition;
+    capitalCallPath?: string;
+    capitalCallValue?: CapitalCallState;
+    positionReceiptPath?: string;
+    positionReceiptValue?: LPPositionReceiptEnvelope;
+    distributionPath?: string;
+    distributionValue?: DistributionDescriptor;
+    distributionPaths?: string[];
+    distributionValues?: DistributionDescriptor[];
+    closingPath?: string;
+    closingValue?: FundClosingDescriptor;
+    verificationReportValue?: FundVerificationReport;
+}): Promise<FundEvidenceBundle>;
+export declare function exportFinalityPayload(sdk: SimplicityClient, input: Parameters<typeof exportEvidence>[1]): Promise<FundFinalityPayload>;