@huma-finance/shared 0.0.48-beta.296 → 0.0.48-beta.298

package/dist/cjs/v2/abis/types/Pool.d.ts

@@ -1,9 +1,12 @@
-import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from 'ethers';
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from 'ethers';
 import type { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
 import type { Listener, Provider } from '@ethersproject/providers';
 import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from './common';
 export interface PoolInterface extends utils.Interface {
     functions: {
+        'closePool()': FunctionFragment;
+        'credit()': FunctionFragment;
+        'creditManager()': FunctionFragment;
         'currentTranchesAssets()': FunctionFragment;
         'disablePool()': FunctionFragment;
         'distributeLoss(uint256)': FunctionFragment;
@@ -12,17 +15,19 @@ export interface PoolInterface extends utils.Interface {
         'enablePool()': FunctionFragment;
         'epochManager()': FunctionFragment;
         'feeManager()': FunctionFragment;
-        'getFirstLossCoverAvailableCap(address,uint256)': FunctionFragment;
         'getFirstLossCovers()': FunctionFragment;
-        'getReservedAssetsForFirstLossCovers()': FunctionFragment;
+        'getTrancheAvailableCap(uint256)': FunctionFragment;
         'initialize(address)': FunctionFragment;
+        'isPoolClosed()': FunctionFragment;
         'isPoolOn()': FunctionFragment;
+        'juniorTranche()': FunctionFragment;
         'poolConfig()': FunctionFragment;
         'poolSafe()': FunctionFragment;
+        'proxiableUUID()': FunctionFragment;
         'readyForFirstLossCoverWithdrawal()': FunctionFragment;
+        'seniorTranche()': FunctionFragment;
         'setPoolConfig(address)': FunctionFragment;
         'setReadyForFirstLossCoverWithdrawal(bool)': FunctionFragment;
-        'syncFirstLossCovers()': FunctionFragment;
         'totalAssets()': FunctionFragment;
         'trancheTotalAssets(uint256)': FunctionFragment;
         'tranchesAssets()': FunctionFragment;
@@ -30,8 +35,13 @@ export interface PoolInterface extends utils.Interface {
         'tranchesPolicy()': FunctionFragment;
         'updatePoolConfigData()': FunctionFragment;
         'updateTranchesAssets(uint96[2])': FunctionFragment;
+        'upgradeTo(address)': FunctionFragment;
+        'upgradeToAndCall(address,bytes)': FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: 'currentTranchesAssets' | 'disablePool' | 'distributeLoss' | 'distributeLossRecovery' | 'distributeProfit' | 'enablePool' | 'epochManager' | 'feeManager' | 'getFirstLossCoverAvailableCap' | 'getFirstLossCovers' | 'getReservedAssetsForFirstLossCovers' | 'initialize' | 'isPoolOn' | 'poolConfig' | 'poolSafe' | 'readyForFirstLossCoverWithdrawal' | 'setPoolConfig' | 'setReadyForFirstLossCoverWithdrawal' | 'syncFirstLossCovers' | 'totalAssets' | 'trancheTotalAssets' | 'tranchesAssets' | 'tranchesLosses' | 'tranchesPolicy' | 'updatePoolConfigData' | 'updateTranchesAssets'): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: 'closePool' | 'credit' | 'creditManager' | 'currentTranchesAssets' | 'disablePool' | 'distributeLoss' | 'distributeLossRecovery' | 'distributeProfit' | 'enablePool' | 'epochManager' | 'feeManager' | 'getFirstLossCovers' | 'getTrancheAvailableCap' | 'initialize' | 'isPoolClosed' | 'isPoolOn' | 'juniorTranche' | 'poolConfig' | 'poolSafe' | 'proxiableUUID' | 'readyForFirstLossCoverWithdrawal' | 'seniorTranche' | 'setPoolConfig' | 'setReadyForFirstLossCoverWithdrawal' | 'totalAssets' | 'trancheTotalAssets' | 'tranchesAssets' | 'tranchesLosses' | 'tranchesPolicy' | 'updatePoolConfigData' | 'updateTranchesAssets' | 'upgradeTo' | 'upgradeToAndCall'): FunctionFragment;
+    encodeFunctionData(functionFragment: 'closePool', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'credit', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'creditManager', values?: undefined): string;
     encodeFunctionData(functionFragment: 'currentTranchesAssets', values?: undefined): string;
     encodeFunctionData(functionFragment: 'disablePool', values?: undefined): string;
     encodeFunctionData(functionFragment: 'distributeLoss', values: [PromiseOrValue<BigNumberish>]): string;
@@ -40,17 +50,19 @@ export interface PoolInterface extends utils.Interface {
     encodeFunctionData(functionFragment: 'enablePool', values?: undefined): string;
     encodeFunctionData(functionFragment: 'epochManager', values?: undefined): string;
     encodeFunctionData(functionFragment: 'feeManager', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'getFirstLossCoverAvailableCap', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: 'getFirstLossCovers', values?: undefined): string;
-    encodeFunctionData(functionFragment: 'getReservedAssetsForFirstLossCovers', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'getTrancheAvailableCap', values: [PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: 'initialize', values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: 'isPoolClosed', values?: undefined): string;
     encodeFunctionData(functionFragment: 'isPoolOn', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'juniorTranche', values?: undefined): string;
     encodeFunctionData(functionFragment: 'poolConfig', values?: undefined): string;
     encodeFunctionData(functionFragment: 'poolSafe', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'proxiableUUID', values?: undefined): string;
     encodeFunctionData(functionFragment: 'readyForFirstLossCoverWithdrawal', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'seniorTranche', values?: undefined): string;
     encodeFunctionData(functionFragment: 'setPoolConfig', values: [PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: 'setReadyForFirstLossCoverWithdrawal', values: [PromiseOrValue<boolean>]): string;
-    encodeFunctionData(functionFragment: 'syncFirstLossCovers', values?: undefined): string;
     encodeFunctionData(functionFragment: 'totalAssets', values?: undefined): string;
     encodeFunctionData(functionFragment: 'trancheTotalAssets', values: [PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: 'tranchesAssets', values?: undefined): string;
@@ -58,6 +70,11 @@ export interface PoolInterface extends utils.Interface {
     encodeFunctionData(functionFragment: 'tranchesPolicy', values?: undefined): string;
     encodeFunctionData(functionFragment: 'updatePoolConfigData', values?: undefined): string;
     encodeFunctionData(functionFragment: 'updateTranchesAssets', values: [[PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]]): string;
+    encodeFunctionData(functionFragment: 'upgradeTo', values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: 'upgradeToAndCall', values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>]): string;
+    decodeFunctionResult(functionFragment: 'closePool', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'credit', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'creditManager', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'currentTranchesAssets', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'disablePool', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'distributeLoss', data: BytesLike): Result;
@@ -66,17 +83,19 @@ export interface PoolInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: 'enablePool', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'epochManager', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'feeManager', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'getFirstLossCoverAvailableCap', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'getFirstLossCovers', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'getReservedAssetsForFirstLossCovers', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'getTrancheAvailableCap', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'isPoolClosed', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'isPoolOn', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'juniorTranche', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'poolConfig', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'poolSafe', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'proxiableUUID', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'readyForFirstLossCoverWithdrawal', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'seniorTranche', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setPoolConfig', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'setReadyForFirstLossCoverWithdrawal', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'syncFirstLossCovers', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'totalAssets', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'trancheTotalAssets', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'tranchesAssets', data: BytesLike): Result;
@@ -84,29 +103,62 @@ export interface PoolInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: 'tranchesPolicy', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'updatePoolConfigData', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'updateTranchesAssets', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'upgradeTo', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'upgradeToAndCall', data: BytesLike): Result;
     events: {
+        'AdminChanged(address,address)': EventFragment;
+        'BeaconUpgraded(address)': EventFragment;
+        'FirstLossCoverWithdrawalReadinessChanged(address,bool)': EventFragment;
         'Initialized(uint8)': EventFragment;
         'LossDistributed(uint256,uint256,uint256,uint256,uint256)': EventFragment;
         'LossRecoveryDistributed(uint256,uint256,uint256,uint256,uint256)': EventFragment;
-        'PoolAssetsRefreshed(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)': EventFragment;
+        'PoolClosed(address)': EventFragment;
         'PoolConfigCacheUpdated(address)': EventFragment;
         'PoolConfigChanged(address,address)': EventFragment;
         'PoolDisabled(address)': EventFragment;
         'PoolEnabled(address)': EventFragment;
-        'PoolReadyForFirstLossCoverWithdrawal(address,bool)': EventFragment;
         'ProfitDistributed(uint256,uint256,uint256)': EventFragment;
+        'Upgraded(address)': EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: 'AdminChanged'): EventFragment;
+    getEvent(nameOrSignatureOrTopic: 'BeaconUpgraded'): EventFragment;
+    getEvent(nameOrSignatureOrTopic: 'FirstLossCoverWithdrawalReadinessChanged'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'LossDistributed'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'LossRecoveryDistributed'): EventFragment;
-    getEvent(nameOrSignatureOrTopic: 'PoolAssetsRefreshed'): EventFragment;
+    getEvent(nameOrSignatureOrTopic: 'PoolClosed'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'PoolConfigCacheUpdated'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'PoolConfigChanged'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'PoolDisabled'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'PoolEnabled'): EventFragment;
-    getEvent(nameOrSignatureOrTopic: 'PoolReadyForFirstLossCoverWithdrawal'): EventFragment;
     getEvent(nameOrSignatureOrTopic: 'ProfitDistributed'): EventFragment;
+    getEvent(nameOrSignatureOrTopic: 'Upgraded'): EventFragment;
 }
+export interface AdminChangedEventObject {
+    previousAdmin: string;
+    newAdmin: string;
+}
+export type AdminChangedEvent = TypedEvent<[
+    string,
+    string
+], AdminChangedEventObject>;
+export type AdminChangedEventFilter = TypedEventFilter<AdminChangedEvent>;
+export interface BeaconUpgradedEventObject {
+    beacon: string;
+}
+export type BeaconUpgradedEvent = TypedEvent<[
+    string
+], BeaconUpgradedEventObject>;
+export type BeaconUpgradedEventFilter = TypedEventFilter<BeaconUpgradedEvent>;
+export interface FirstLossCoverWithdrawalReadinessChangedEventObject {
+    by: string;
+    ready: boolean;
+}
+export type FirstLossCoverWithdrawalReadinessChangedEvent = TypedEvent<[
+    string,
+    boolean
+], FirstLossCoverWithdrawalReadinessChangedEventObject>;
+export type FirstLossCoverWithdrawalReadinessChangedEventFilter = TypedEventFilter<FirstLossCoverWithdrawalReadinessChangedEvent>;
 export interface InitializedEventObject {
     version: number;
 }
@@ -142,27 +194,11 @@ export type LossRecoveryDistributedEvent = TypedEvent<[
     BigNumber
 ], LossRecoveryDistributedEventObject>;
 export type LossRecoveryDistributedEventFilter = TypedEventFilter<LossRecoveryDistributedEvent>;
-export interface PoolAssetsRefreshedEventObject {
-    refreshedTimestamp: BigNumber;
-    profit: BigNumber;
-    loss: BigNumber;
-    lossRecovery: BigNumber;
-    seniorTotalAssets: BigNumber;
-    juniorTotalAssets: BigNumber;
-    seniorTotalLoss: BigNumber;
-    juniorTotalLoss: BigNumber;
+export interface PoolClosedEventObject {
+    by: string;
 }
-export type PoolAssetsRefreshedEvent = TypedEvent<[
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    BigNumber
-], PoolAssetsRefreshedEventObject>;
-export type PoolAssetsRefreshedEventFilter = TypedEventFilter<PoolAssetsRefreshedEvent>;
+export type PoolClosedEvent = TypedEvent<[string], PoolClosedEventObject>;
+export type PoolClosedEventFilter = TypedEventFilter<PoolClosedEvent>;
 export interface PoolConfigCacheUpdatedEventObject {
     poolConfig: string;
 }
@@ -189,15 +225,6 @@ export interface PoolEnabledEventObject {
 }
 export type PoolEnabledEvent = TypedEvent<[string], PoolEnabledEventObject>;
 export type PoolEnabledEventFilter = TypedEventFilter<PoolEnabledEvent>;
-export interface PoolReadyForFirstLossCoverWithdrawalEventObject {
-    by: string;
-    ready: boolean;
-}
-export type PoolReadyForFirstLossCoverWithdrawalEvent = TypedEvent<[
-    string,
-    boolean
-], PoolReadyForFirstLossCoverWithdrawalEventObject>;
-export type PoolReadyForFirstLossCoverWithdrawalEventFilter = TypedEventFilter<PoolReadyForFirstLossCoverWithdrawalEvent>;
 export interface ProfitDistributedEventObject {
     profit: BigNumber;
     seniorTotalAssets: BigNumber;
@@ -209,6 +236,11 @@ export type ProfitDistributedEvent = TypedEvent<[
     BigNumber
 ], ProfitDistributedEventObject>;
 export type ProfitDistributedEventFilter = TypedEventFilter<ProfitDistributedEvent>;
+export interface UpgradedEventObject {
+    implementation: string;
+}
+export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>;
+export type UpgradedEventFilter = TypedEventFilter<UpgradedEvent>;
 export interface Pool extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
@@ -224,6 +256,11 @@ export interface Pool extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
+        closePool(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        credit(overrides?: CallOverrides): Promise<[string]>;
+        creditManager(overrides?: CallOverrides): Promise<[string]>;
         currentTranchesAssets(overrides?: CallOverrides): Promise<[[BigNumber, BigNumber]] & {
             assets: [BigNumber, BigNumber];
         }>;
@@ -244,41 +281,39 @@ export interface Pool extends BaseContract {
         }): Promise<ContractTransaction>;
         epochManager(overrides?: CallOverrides): Promise<[string]>;
         feeManager(overrides?: CallOverrides): Promise<[string]>;
-        getFirstLossCoverAvailableCap(coverAddress: PromiseOrValue<string>, poolAssets: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber] & {
-            availableCap: BigNumber;
-        }>;
         getFirstLossCovers(overrides?: CallOverrides): Promise<[string[]]>;
-        getReservedAssetsForFirstLossCovers(overrides?: CallOverrides): Promise<[BigNumber] & {
-            reservedAssets: BigNumber;
+        getTrancheAvailableCap(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber] & {
+            availableCap: BigNumber;
         }>;
-        initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
+        initialize(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
+        isPoolClosed(overrides?: CallOverrides): Promise<[boolean] & {
+            isClosed: boolean;
+        }>;
         isPoolOn(overrides?: CallOverrides): Promise<[boolean] & {
-            status: boolean;
+            isOn: boolean;
         }>;
+        juniorTranche(overrides?: CallOverrides): Promise<[string]>;
         poolConfig(overrides?: CallOverrides): Promise<[string]>;
         poolSafe(overrides?: CallOverrides): Promise<[string]>;
+        proxiableUUID(overrides?: CallOverrides): Promise<[string]>;
         readyForFirstLossCoverWithdrawal(overrides?: CallOverrides): Promise<[boolean]>;
-        setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
+        seniorTranche(overrides?: CallOverrides): Promise<[string]>;
+        setPoolConfig(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
-        setReadyForFirstLossCoverWithdrawal(ready: PromiseOrValue<boolean>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<ContractTransaction>;
-        syncFirstLossCovers(overrides?: Overrides & {
+        setReadyForFirstLossCoverWithdrawal(isReady: PromiseOrValue<boolean>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         totalAssets(overrides?: CallOverrides): Promise<[BigNumber]>;
         trancheTotalAssets(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
         tranchesAssets(overrides?: CallOverrides): Promise<[
-            BigNumber,
             BigNumber,
             BigNumber
         ] & {
             seniorTotalAssets: BigNumber;
             juniorTotalAssets: BigNumber;
-            lastProfitDistributedTime: BigNumber;
         }>;
         tranchesLosses(overrides?: CallOverrides): Promise<[
             BigNumber,
@@ -294,7 +329,18 @@ export interface Pool extends BaseContract {
         updateTranchesAssets(assets: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
     };
+    closePool(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    credit(overrides?: CallOverrides): Promise<string>;
+    creditManager(overrides?: CallOverrides): Promise<string>;
     currentTranchesAssets(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
     disablePool(overrides?: Overrides & {
         from?: PromiseOrValue<string>;
@@ -313,35 +359,33 @@ export interface Pool extends BaseContract {
     }): Promise<ContractTransaction>;
     epochManager(overrides?: CallOverrides): Promise<string>;
     feeManager(overrides?: CallOverrides): Promise<string>;
-    getFirstLossCoverAvailableCap(coverAddress: PromiseOrValue<string>, poolAssets: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
     getFirstLossCovers(overrides?: CallOverrides): Promise<string[]>;
-    getReservedAssetsForFirstLossCovers(overrides?: CallOverrides): Promise<BigNumber>;
-    initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
+    getTrancheAvailableCap(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+    initialize(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
+    isPoolClosed(overrides?: CallOverrides): Promise<boolean>;
     isPoolOn(overrides?: CallOverrides): Promise<boolean>;
+    juniorTranche(overrides?: CallOverrides): Promise<string>;
     poolConfig(overrides?: CallOverrides): Promise<string>;
     poolSafe(overrides?: CallOverrides): Promise<string>;
+    proxiableUUID(overrides?: CallOverrides): Promise<string>;
     readyForFirstLossCoverWithdrawal(overrides?: CallOverrides): Promise<boolean>;
-    setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
+    seniorTranche(overrides?: CallOverrides): Promise<string>;
+    setPoolConfig(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
-    setReadyForFirstLossCoverWithdrawal(ready: PromiseOrValue<boolean>, overrides?: Overrides & {
-        from?: PromiseOrValue<string>;
-    }): Promise<ContractTransaction>;
-    syncFirstLossCovers(overrides?: Overrides & {
+    setReadyForFirstLossCoverWithdrawal(isReady: PromiseOrValue<boolean>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
     trancheTotalAssets(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
     tranchesAssets(overrides?: CallOverrides): Promise<[
-        BigNumber,
         BigNumber,
         BigNumber
     ] & {
         seniorTotalAssets: BigNumber;
         juniorTotalAssets: BigNumber;
-        lastProfitDistributedTime: BigNumber;
     }>;
     tranchesLosses(overrides?: CallOverrides): Promise<[
         BigNumber,
@@ -357,7 +401,16 @@ export interface Pool extends BaseContract {
     updateTranchesAssets(assets: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
+    upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
     callStatic: {
+        closePool(overrides?: CallOverrides): Promise<void>;
+        credit(overrides?: CallOverrides): Promise<string>;
+        creditManager(overrides?: CallOverrides): Promise<string>;
         currentTranchesAssets(overrides?: CallOverrides): Promise<[BigNumber, BigNumber]>;
         disablePool(overrides?: CallOverrides): Promise<void>;
         distributeLoss(loss: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
@@ -366,27 +419,27 @@ export interface Pool extends BaseContract {
         enablePool(overrides?: CallOverrides): Promise<void>;
         epochManager(overrides?: CallOverrides): Promise<string>;
         feeManager(overrides?: CallOverrides): Promise<string>;
-        getFirstLossCoverAvailableCap(coverAddress: PromiseOrValue<string>, poolAssets: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
         getFirstLossCovers(overrides?: CallOverrides): Promise<string[]>;
-        getReservedAssetsForFirstLossCovers(overrides?: CallOverrides): Promise<BigNumber>;
-        initialize(_poolConfig: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        getTrancheAvailableCap(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(poolConfig_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        isPoolClosed(overrides?: CallOverrides): Promise<boolean>;
         isPoolOn(overrides?: CallOverrides): Promise<boolean>;
+        juniorTranche(overrides?: CallOverrides): Promise<string>;
         poolConfig(overrides?: CallOverrides): Promise<string>;
         poolSafe(overrides?: CallOverrides): Promise<string>;
+        proxiableUUID(overrides?: CallOverrides): Promise<string>;
         readyForFirstLossCoverWithdrawal(overrides?: CallOverrides): Promise<boolean>;
-        setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
-        setReadyForFirstLossCoverWithdrawal(ready: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
-        syncFirstLossCovers(overrides?: CallOverrides): Promise<void>;
+        seniorTranche(overrides?: CallOverrides): Promise<string>;
+        setPoolConfig(poolConfig_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        setReadyForFirstLossCoverWithdrawal(isReady: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
         totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
         trancheTotalAssets(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
         tranchesAssets(overrides?: CallOverrides): Promise<[
-            BigNumber,
             BigNumber,
             BigNumber
         ] & {
             seniorTotalAssets: BigNumber;
             juniorTotalAssets: BigNumber;
-            lastProfitDistributedTime: BigNumber;
         }>;
         tranchesLosses(overrides?: CallOverrides): Promise<[
             BigNumber,
@@ -398,16 +451,24 @@ export interface Pool extends BaseContract {
         tranchesPolicy(overrides?: CallOverrides): Promise<string>;
         updatePoolConfigData(overrides?: CallOverrides): Promise<void>;
         updateTranchesAssets(assets: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], overrides?: CallOverrides): Promise<void>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
     };
     filters: {
+        'AdminChanged(address,address)'(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
+        AdminChanged(previousAdmin?: null, newAdmin?: null): AdminChangedEventFilter;
+        'BeaconUpgraded(address)'(beacon?: PromiseOrValue<string> | null): BeaconUpgradedEventFilter;
+        BeaconUpgraded(beacon?: PromiseOrValue<string> | null): BeaconUpgradedEventFilter;
+        'FirstLossCoverWithdrawalReadinessChanged(address,bool)'(by?: PromiseOrValue<string> | null, ready?: null): FirstLossCoverWithdrawalReadinessChangedEventFilter;
+        FirstLossCoverWithdrawalReadinessChanged(by?: PromiseOrValue<string> | null, ready?: null): FirstLossCoverWithdrawalReadinessChangedEventFilter;
         'Initialized(uint8)'(version?: null): InitializedEventFilter;
         Initialized(version?: null): InitializedEventFilter;
         'LossDistributed(uint256,uint256,uint256,uint256,uint256)'(loss?: null, seniorTotalAssets?: null, juniorTotalAssets?: null, seniorTotalLoss?: null, juniorTotalLoss?: null): LossDistributedEventFilter;
         LossDistributed(loss?: null, seniorTotalAssets?: null, juniorTotalAssets?: null, seniorTotalLoss?: null, juniorTotalLoss?: null): LossDistributedEventFilter;
         'LossRecoveryDistributed(uint256,uint256,uint256,uint256,uint256)'(lossRecovery?: null, seniorTotalAssets?: null, juniorTotalAssets?: null, seniorTotalLoss?: null, juniorTotalLoss?: null): LossRecoveryDistributedEventFilter;
         LossRecoveryDistributed(lossRecovery?: null, seniorTotalAssets?: null, juniorTotalAssets?: null, seniorTotalLoss?: null, juniorTotalLoss?: null): LossRecoveryDistributedEventFilter;
-        'PoolAssetsRefreshed(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)'(refreshedTimestamp?: null, profit?: null, loss?: null, lossRecovery?: null, seniorTotalAssets?: null, juniorTotalAssets?: null, seniorTotalLoss?: null, juniorTotalLoss?: null): PoolAssetsRefreshedEventFilter;
-        PoolAssetsRefreshed(refreshedTimestamp?: null, profit?: null, loss?: null, lossRecovery?: null, seniorTotalAssets?: null, juniorTotalAssets?: null, seniorTotalLoss?: null, juniorTotalLoss?: null): PoolAssetsRefreshedEventFilter;
+        'PoolClosed(address)'(by?: PromiseOrValue<string> | null): PoolClosedEventFilter;
+        PoolClosed(by?: PromiseOrValue<string> | null): PoolClosedEventFilter;
         'PoolConfigCacheUpdated(address)'(poolConfig?: PromiseOrValue<string> | null): PoolConfigCacheUpdatedEventFilter;
         PoolConfigCacheUpdated(poolConfig?: PromiseOrValue<string> | null): PoolConfigCacheUpdatedEventFilter;
         'PoolConfigChanged(address,address)'(newPoolConfig?: PromiseOrValue<string> | null, oldPoolConfig?: PromiseOrValue<string> | null): PoolConfigChangedEventFilter;
@@ -416,12 +477,17 @@ export interface Pool extends BaseContract {
         PoolDisabled(by?: PromiseOrValue<string> | null): PoolDisabledEventFilter;
         'PoolEnabled(address)'(by?: PromiseOrValue<string> | null): PoolEnabledEventFilter;
         PoolEnabled(by?: PromiseOrValue<string> | null): PoolEnabledEventFilter;
-        'PoolReadyForFirstLossCoverWithdrawal(address,bool)'(by?: PromiseOrValue<string> | null, ready?: null): PoolReadyForFirstLossCoverWithdrawalEventFilter;
-        PoolReadyForFirstLossCoverWithdrawal(by?: PromiseOrValue<string> | null, ready?: null): PoolReadyForFirstLossCoverWithdrawalEventFilter;
         'ProfitDistributed(uint256,uint256,uint256)'(profit?: null, seniorTotalAssets?: null, juniorTotalAssets?: null): ProfitDistributedEventFilter;
         ProfitDistributed(profit?: null, seniorTotalAssets?: null, juniorTotalAssets?: null): ProfitDistributedEventFilter;
+        'Upgraded(address)'(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
+        Upgraded(implementation?: PromiseOrValue<string> | null): UpgradedEventFilter;
     };
     estimateGas: {
+        closePool(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        credit(overrides?: CallOverrides): Promise<BigNumber>;
+        creditManager(overrides?: CallOverrides): Promise<BigNumber>;
         currentTranchesAssets(overrides?: CallOverrides): Promise<BigNumber>;
         disablePool(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -440,23 +506,23 @@ export interface Pool extends BaseContract {
         }): Promise<BigNumber>;
         epochManager(overrides?: CallOverrides): Promise<BigNumber>;
         feeManager(overrides?: CallOverrides): Promise<BigNumber>;
-        getFirstLossCoverAvailableCap(coverAddress: PromiseOrValue<string>, poolAssets: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
         getFirstLossCovers(overrides?: CallOverrides): Promise<BigNumber>;
-        getReservedAssetsForFirstLossCovers(overrides?: CallOverrides): Promise<BigNumber>;
-        initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
+        getTrancheAvailableCap(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
+        isPoolClosed(overrides?: CallOverrides): Promise<BigNumber>;
         isPoolOn(overrides?: CallOverrides): Promise<BigNumber>;
+        juniorTranche(overrides?: CallOverrides): Promise<BigNumber>;
         poolConfig(overrides?: CallOverrides): Promise<BigNumber>;
         poolSafe(overrides?: CallOverrides): Promise<BigNumber>;
+        proxiableUUID(overrides?: CallOverrides): Promise<BigNumber>;
         readyForFirstLossCoverWithdrawal(overrides?: CallOverrides): Promise<BigNumber>;
-        setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<BigNumber>;
-        setReadyForFirstLossCoverWithdrawal(ready: PromiseOrValue<boolean>, overrides?: Overrides & {
+        seniorTranche(overrides?: CallOverrides): Promise<BigNumber>;
+        setPoolConfig(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
-        syncFirstLossCovers(overrides?: Overrides & {
+        setReadyForFirstLossCoverWithdrawal(isReady: PromiseOrValue<boolean>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         totalAssets(overrides?: CallOverrides): Promise<BigNumber>;
@@ -470,8 +536,19 @@ export interface Pool extends BaseContract {
         updateTranchesAssets(assets: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
     };
     populateTransaction: {
+        closePool(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        credit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        creditManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         currentTranchesAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         disablePool(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
@@ -490,23 +567,23 @@ export interface Pool extends BaseContract {
         }): Promise<PopulatedTransaction>;
         epochManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         feeManager(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getFirstLossCoverAvailableCap(coverAddress: PromiseOrValue<string>, poolAssets: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         getFirstLossCovers(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getReservedAssetsForFirstLossCovers(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        initialize(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
+        getTrancheAvailableCap(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
+        isPoolClosed(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         isPoolOn(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        juniorTranche(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         poolConfig(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         poolSafe(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        proxiableUUID(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         readyForFirstLossCoverWithdrawal(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        setPoolConfig(_poolConfig: PromiseOrValue<string>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<PopulatedTransaction>;
-        setReadyForFirstLossCoverWithdrawal(ready: PromiseOrValue<boolean>, overrides?: Overrides & {
+        seniorTranche(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setPoolConfig(poolConfig_: PromiseOrValue<string>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
-        syncFirstLossCovers(overrides?: Overrides & {
+        setReadyForFirstLossCoverWithdrawal(isReady: PromiseOrValue<boolean>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         totalAssets(overrides?: CallOverrides): Promise<PopulatedTransaction>;
@@ -520,5 +597,11 @@ export interface Pool extends BaseContract {
         updateTranchesAssets(assets: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
+        upgradeTo(newImplementation: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        upgradeToAndCall(newImplementation: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
     };
 }