ReserveManager_v1

function activateEndowment() external;

function cancelUnbackedDrawCeilingChange(bytes32 operationHash_) external;

function closePosition(uint id_) external;

function draw(uint id_, address to_, uint reserveAmount_) external;

function drawUnbackedReserves(uint amount_) external;

function executeUnbackedDrawCeilingChange(uint newCeilingBps_, bytes32 operationHash_) external;

function finalizeEndowmentSetup() external;

function lockAndDraw(uint id_, uint issuanceToLock_, address to_, uint reserveAmount_) external;

function mergePositions(
    uint[] calldata ids_
) external returns (uint newId_, uint lockedIssuance_, uint outstandingReserves_);

function openPosition(
    uint issuanceAmount_,
    address to_,
    uint reserveAmount_
) external returns (uint id_);

function queueUnbackedDrawCeilingChange(
    uint newCeilingBps_
) external returns (bytes32 operationHash_);

function registerEndowmentController() external;

function repay(uint id_, uint reserveAmount_) external returns (uint issuanceReleased_);

function restoreUnbackedReserves(uint amount_) external;

function getEndowmentAdmin() external view returns (address admin_);

function getEndowmentController() external view returns (address controller_);

function getExpectedEndowmentController() external view returns (address controller_);

function getPendingUnbackedDrawCeilingChange() external view returns (PendingUnbackedDrawCeilingChange memory pending_);

function getPendingUnbackedDrawCeilingQueueVcs() external view returns (uint queueVcs_);

function getPosition(address module_, uint id_) external view returns (Position memory position_);

function getTotalLockedIssuance() external view returns (uint total_);

function getTotalOutstandingReserves() external view returns (uint total_);

function getTotalUnbackedReserveDrawn() external view returns (uint total_);

function getUnbackedDrawCeilingAmount() external view returns (uint ceiling_);

function getUnbackedDrawCeilingBaseVcs() external view returns (uint recordedVcs_);

function getUnbackedDrawCeilingBps() external view returns (uint ceilingBps_);

function getUnbackedDrawnBy(address account_) external view returns (uint amount_);

function isEndowmentActivated() external view returns (bool activated_);

function isEndowmentSetupOpen() external view returns (bool open_);

function isPendingUnbackedDrawCeilingChangeExpired() external view returns (bool expired_);

function isPositionOpen(address module_, uint id_) external view returns (bool isOpen_);

function isUnbackedDrawsAllowed() external view returns (bool allowed_);

event EndowmentActivated(address indexed controller_, address indexed admin_);

event EndowmentControllerRegistered(address indexed controller_, address indexed admin_);

event EndowmentSetupFinalized(address indexed admin_);

event IssuanceLocked(address indexed module_, uint indexed id_, uint amount_);

event PositionClosed(address indexed module_, uint indexed id_);

event PositionOpened(address indexed module_, uint indexed id_, uint lockedIssuance_);

event PositionsMerged(
    address indexed module_,
    uint[] oldIds_,
    uint indexed newId_,
    uint lockedIssuance_,
    uint outstandingReserves_
);

event Repaid(
    address indexed module_,
    uint indexed id_,
    uint reserveRepaid_,
    uint issuanceReleased_
);

event ReservesDrawn(address indexed module_, uint indexed id_, address indexed to_, uint amount_);

event UnbackedDrawCeilingBaseRecorded(uint indexed nonce_, uint recordedVirtualCollateralSupply_);

event UnbackedDrawCeilingChangeCancelled(uint indexed nonce_, bytes32 indexed operationHash_);

event UnbackedDrawCeilingChangeExecuted(
    uint indexed nonce_,
    bytes32 indexed operationHash_,
    uint previousCeilingBps_,
    uint newCeilingBps_
);

event UnbackedDrawCeilingChangeQueued(
    uint indexed nonce_,
    bytes32 indexed operationHash_,
    uint newCeilingBps_,
    uint executeAfter_,
    uint expiresAt_
);

event UnbackedDrawCeilingQueueVcsRecorded(uint indexed nonce_, uint queueVirtualCollateralSupply_);

event UnbackedDrawPolicyInitialized(bool allowed_, uint ceilingBps_);

event UnbackedReservesDrawn(address indexed adr_, uint amount_);

event UnbackedReservesRestored(address indexed adr_, uint amount_);

error ReserveManager__ApprovalSafeCannotQueue(address caller_);

error ReserveManager__CallerNotApprovalSafe(address caller_);

error ReserveManager__CeilingRequiresUnbackedDraws(uint ceilingBps_);

error ReserveManager__EndowmentAdminOnly(address caller_, address admin_);

error ReserveManager__EndowmentAlreadyActivated();

error ReserveManager__EndowmentControllerAlreadyRegistered(address controller_);

error ReserveManager__EndowmentControllerNotRegistered();

error ReserveManager__EndowmentControllerOnly(address caller_, address controller_);

error ReserveManager__EndowmentCurveUnsupported(address curve_);

error ReserveManager__EndowmentDrawExceedsReferenceValue(uint totalDrawn_, uint candidateValue_);

error ReserveManager__EndowmentExpectedControllerOnly(address caller_, address expected_);

error ReserveManager__EndowmentMarketNotReady(bool setupOpen_, bool activated_);

error ReserveManager__EndowmentNotActivated();

error ReserveManager__EndowmentPriorExposure();

error ReserveManager__EndowmentSetupIdentitiesMustDiffer(address controller_, address admin_);

error ReserveManager__EndowmentSetupIdentityZero();

error ReserveManager__EndowmentSetupNotOpen();

error ReserveManager__EndowmentSetupNotReady(bool registered_, bool activated_);

error ReserveManager__EndowmentSetupOpen();

error ReserveManager__InvalidEndowmentInitConfig();

error ReserveManager__InvalidInitConfigLength(uint length_);

error ReserveManager__InvalidUnbackedDrawCeilingBps(uint ceilingBps_);

error ReserveManager__MergeRequiresAtLeastTwoPositions(uint count_);

error ReserveManager__NoPendingUnbackedDrawCeilingChange();

error ReserveManager__PositionNotEmpty(uint lockedIssuance_, uint outstandingReserves_);

error ReserveManager__PositionNotOpen(address module_, uint id_);

error ReserveManager__PositionUndercollateralized(
    uint outstandingReserves_,
    uint lockedIssuance_,
    uint referencePrice_
);

error ReserveManager__RepaymentExceedsOutstanding(uint requested_, uint outstanding_);

error ReserveManager__UnbackedDrawCeilingChangeAlreadyQueued(bytes32 operationHash_);

error ReserveManager__UnbackedDrawCeilingChangeExpired(uint expiresAt_);

error ReserveManager__UnbackedDrawCeilingChangeHashMismatch(bytes32 expected_, bytes32 provided_);

error ReserveManager__UnbackedDrawCeilingChangeTooEarly(uint executeAfter_);

error ReserveManager__UnbackedDrawCeilingExceeded(uint requested_, uint ceiling_);

error ReserveManager__UnbackedDrawsNotAllowed();