import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, 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 } from "./common";
export type EmergencyWithdrawInputStruct = {
    user: string;
    lockId: BigNumberish;
    withdrawAmount: BigNumberish;
};
export type EmergencyWithdrawInputStructOutput = [
    string,
    BigNumber,
    BigNumber
] & {
    user: string;
    lockId: BigNumber;
    withdrawAmount: BigNumber;
};
export declare namespace IKSULocking {
    type LockPeriodDetailsStruct = {
        rKSUMultiplier: BigNumberish;
        ksuBonusMultiplier: BigNumberish;
        isActive: boolean;
    };
    type LockPeriodDetailsStructOutput = [
        BigNumber,
        BigNumber,
        boolean
    ] & {
        rKSUMultiplier: BigNumber;
        ksuBonusMultiplier: BigNumber;
        isActive: boolean;
    };
    type ERC20PermitPayloadStruct = {
        value: BigNumberish;
        deadline: BigNumberish;
        v: BigNumberish;
        r: BytesLike;
        s: BytesLike;
    };
    type ERC20PermitPayloadStructOutput = [
        BigNumber,
        BigNumber,
        number,
        string,
        string
    ] & {
        value: BigNumber;
        deadline: BigNumber;
        v: number;
        r: string;
        s: string;
    };
    type UserLockStruct = {
        amount: BigNumberish;
        rKSUAmount: BigNumberish;
        rKSUMultiplier: BigNumberish;
        startTime: BigNumberish;
        lockPeriod: BigNumberish;
    };
    type UserLockStructOutput = [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        amount: BigNumber;
        rKSUAmount: BigNumber;
        rKSUMultiplier: BigNumber;
        startTime: BigNumber;
        lockPeriod: BigNumber;
    };
}
export interface IKSULockingAbiInterface extends utils.Interface {
    functions: {
        "addLockPeriod(uint256,uint256,uint256)": FunctionFragment;
        "allowance(address,address)": FunctionFragment;
        "approve(address,uint256)": FunctionFragment;
        "balanceOf(address)": FunctionFragment;
        "claimFees()": FunctionFragment;
        "emergencyWithdraw((address,uint256,uint256)[],address)": FunctionFragment;
        "emitFees(uint256)": FunctionFragment;
        "lock(uint256,uint256)": FunctionFragment;
        "lockDetails(uint256)": FunctionFragment;
        "lockWithPermit(uint256,uint256,(uint256,uint256,uint8,bytes32,bytes32))": FunctionFragment;
        "rewards(address)": FunctionFragment;
        "setKSULockBonus(address)": FunctionFragment;
        "totalSupply()": FunctionFragment;
        "transfer(address,uint256)": FunctionFragment;
        "transferFrom(address,address,uint256)": FunctionFragment;
        "unlock(uint256,uint256)": FunctionFragment;
        "userLock(address,uint256)": FunctionFragment;
        "userTotalDeposits(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "addLockPeriod" | "allowance" | "approve" | "balanceOf" | "claimFees" | "emergencyWithdraw" | "emitFees" | "lock" | "lockDetails" | "lockWithPermit" | "rewards" | "setKSULockBonus" | "totalSupply" | "transfer" | "transferFrom" | "unlock" | "userLock" | "userTotalDeposits"): FunctionFragment;
    encodeFunctionData(functionFragment: "addLockPeriod", values: [BigNumberish, BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "allowance", values: [string, string]): string;
    encodeFunctionData(functionFragment: "approve", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
    encodeFunctionData(functionFragment: "claimFees", values?: undefined): string;
    encodeFunctionData(functionFragment: "emergencyWithdraw", values: [EmergencyWithdrawInputStruct[], string]): string;
    encodeFunctionData(functionFragment: "emitFees", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "lock", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "lockDetails", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "lockWithPermit", values: [BigNumberish, BigNumberish, IKSULocking.ERC20PermitPayloadStruct]): string;
    encodeFunctionData(functionFragment: "rewards", values: [string]): string;
    encodeFunctionData(functionFragment: "setKSULockBonus", values: [string]): string;
    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
    encodeFunctionData(functionFragment: "transfer", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "transferFrom", values: [string, string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "unlock", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "userLock", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "userTotalDeposits", values: [string]): string;
    decodeFunctionResult(functionFragment: "addLockPeriod", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "claimFees", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "emergencyWithdraw", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "emitFees", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockDetails", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockWithPermit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setKSULockBonus", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "userLock", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "userTotalDeposits", data: BytesLike): Result;
    events: {
        "Approval(address,address,uint256)": EventFragment;
        "EmergencyWithdraw(address,uint256,uint256,uint256,address)": EventFragment;
        "FeesClaimed(address,uint256)": EventFragment;
        "FeesEmitted(address,uint256)": EventFragment;
        "LockPeriodAdded(uint256,uint256,uint256)": EventFragment;
        "Transfer(address,address,uint256)": EventFragment;
        "UserLocked(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
        "UserUnlocked(address,uint256,uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "EmergencyWithdraw"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "FeesClaimed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "FeesEmitted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LockPeriodAdded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UserLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UserUnlocked"): EventFragment;
}
export interface ApprovalEventObject {
    owner: string;
    spender: string;
    value: BigNumber;
}
export type ApprovalEvent = TypedEvent<[
    string,
    string,
    BigNumber
], ApprovalEventObject>;
export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
export interface EmergencyWithdrawEventObject {
    user: string;
    lockId: BigNumber;
    ksuAmount: BigNumber;
    rKSUBurned: BigNumber;
    receiver: string;
}
export type EmergencyWithdrawEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    string
], EmergencyWithdrawEventObject>;
export type EmergencyWithdrawEventFilter = TypedEventFilter<EmergencyWithdrawEvent>;
export interface FeesClaimedEventObject {
    user: string;
    amount: BigNumber;
}
export type FeesClaimedEvent = TypedEvent<[
    string,
    BigNumber
], FeesClaimedEventObject>;
export type FeesClaimedEventFilter = TypedEventFilter<FeesClaimedEvent>;
export interface FeesEmittedEventObject {
    user: string;
    amount: BigNumber;
}
export type FeesEmittedEvent = TypedEvent<[
    string,
    BigNumber
], FeesEmittedEventObject>;
export type FeesEmittedEventFilter = TypedEventFilter<FeesEmittedEvent>;
export interface LockPeriodAddedEventObject {
    lockPeriod: BigNumber;
    rKSUMultiplier: BigNumber;
    ksuBonusMultiplier: BigNumber;
}
export type LockPeriodAddedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], LockPeriodAddedEventObject>;
export type LockPeriodAddedEventFilter = TypedEventFilter<LockPeriodAddedEvent>;
export interface TransferEventObject {
    from: string;
    to: string;
    value: BigNumber;
}
export type TransferEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TransferEventObject>;
export type TransferEventFilter = TypedEventFilter<TransferEvent>;
export interface UserLockedEventObject {
    user: string;
    lockId: BigNumber;
    lockPeriod: BigNumber;
    ksuAmount: BigNumber;
    ksuBonusAmount: BigNumber;
    rKSUMinted: BigNumber;
}
export type UserLockedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], UserLockedEventObject>;
export type UserLockedEventFilter = TypedEventFilter<UserLockedEvent>;
export interface UserUnlockedEventObject {
    user: string;
    lockId: BigNumber;
    ksuAmount: BigNumber;
    rKSUBurned: BigNumber;
}
export type UserUnlockedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    BigNumber
], UserUnlockedEventObject>;
export type UserUnlockedEventFilter = TypedEventFilter<UserUnlockedEvent>;
export interface IKSULockingAbi extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: IKSULockingAbiInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        addLockPeriod(lockPeriod: BigNumberish, rKSUMultiplier: BigNumberish, ksuBonusMultiplier: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        approve(spender: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        claimFees(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        emergencyWithdraw(emergencyWithdrawInput: EmergencyWithdrawInputStruct[], receiver: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        emitFees(amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        lock(amount: BigNumberish, lockPeriod: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        lockDetails(lockPeriod: BigNumberish, overrides?: CallOverrides): Promise<[IKSULocking.LockPeriodDetailsStructOutput]>;
        lockWithPermit(amount: BigNumberish, lockPeriod: BigNumberish, ksuPermit: IKSULocking.ERC20PermitPayloadStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        rewards(user: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        setKSULockBonus(ksuBonusTokens_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        transfer(to: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        transferFrom(from: string, to: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unlock(amount: BigNumberish, userLockId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        userLock(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[IKSULocking.UserLockStructOutput]>;
        userTotalDeposits(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
    };
    addLockPeriod(lockPeriod: BigNumberish, rKSUMultiplier: BigNumberish, ksuBonusMultiplier: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
    approve(spender: string, value: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
    claimFees(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    emergencyWithdraw(emergencyWithdrawInput: EmergencyWithdrawInputStruct[], receiver: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    emitFees(amount: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    lock(amount: BigNumberish, lockPeriod: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    lockDetails(lockPeriod: BigNumberish, overrides?: CallOverrides): Promise<IKSULocking.LockPeriodDetailsStructOutput>;
    lockWithPermit(amount: BigNumberish, lockPeriod: BigNumberish, ksuPermit: IKSULocking.ERC20PermitPayloadStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    rewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;
    setKSULockBonus(ksuBonusTokens_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
    transfer(to: string, value: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    transferFrom(from: string, to: string, value: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unlock(amount: BigNumberish, userLockId: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    userLock(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<IKSULocking.UserLockStructOutput>;
    userTotalDeposits(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    callStatic: {
        addLockPeriod(lockPeriod: BigNumberish, rKSUMultiplier: BigNumberish, ksuBonusMultiplier: BigNumberish, overrides?: CallOverrides): Promise<void>;
        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
        approve(spender: string, value: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
        claimFees(overrides?: CallOverrides): Promise<BigNumber>;
        emergencyWithdraw(emergencyWithdrawInput: EmergencyWithdrawInputStruct[], receiver: string, overrides?: CallOverrides): Promise<void>;
        emitFees(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
        lock(amount: BigNumberish, lockPeriod: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        lockDetails(lockPeriod: BigNumberish, overrides?: CallOverrides): Promise<IKSULocking.LockPeriodDetailsStructOutput>;
        lockWithPermit(amount: BigNumberish, lockPeriod: BigNumberish, ksuPermit: IKSULocking.ERC20PermitPayloadStruct, overrides?: CallOverrides): Promise<BigNumber>;
        rewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;
        setKSULockBonus(ksuBonusTokens_: string, overrides?: CallOverrides): Promise<void>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(to: string, value: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        transferFrom(from: string, to: string, value: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        unlock(amount: BigNumberish, userLockId: BigNumberish, overrides?: CallOverrides): Promise<void>;
        userLock(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<IKSULocking.UserLockStructOutput>;
        userTotalDeposits(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    };
    filters: {
        "Approval(address,address,uint256)"(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
        Approval(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
        "EmergencyWithdraw(address,uint256,uint256,uint256,address)"(user?: string | null, lockId?: BigNumberish | null, ksuAmount?: null, rKSUBurned?: null, receiver?: null): EmergencyWithdrawEventFilter;
        EmergencyWithdraw(user?: string | null, lockId?: BigNumberish | null, ksuAmount?: null, rKSUBurned?: null, receiver?: null): EmergencyWithdrawEventFilter;
        "FeesClaimed(address,uint256)"(user?: string | null, amount?: null): FeesClaimedEventFilter;
        FeesClaimed(user?: string | null, amount?: null): FeesClaimedEventFilter;
        "FeesEmitted(address,uint256)"(user?: string | null, amount?: null): FeesEmittedEventFilter;
        FeesEmitted(user?: string | null, amount?: null): FeesEmittedEventFilter;
        "LockPeriodAdded(uint256,uint256,uint256)"(lockPeriod?: BigNumberish | null, rKSUMultiplier?: null, ksuBonusMultiplier?: null): LockPeriodAddedEventFilter;
        LockPeriodAdded(lockPeriod?: BigNumberish | null, rKSUMultiplier?: null, ksuBonusMultiplier?: null): LockPeriodAddedEventFilter;
        "Transfer(address,address,uint256)"(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
        Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
        "UserLocked(address,uint256,uint256,uint256,uint256,uint256)"(user?: string | null, lockId?: BigNumberish | null, lockPeriod?: BigNumberish | null, ksuAmount?: null, ksuBonusAmount?: null, rKSUMinted?: null): UserLockedEventFilter;
        UserLocked(user?: string | null, lockId?: BigNumberish | null, lockPeriod?: BigNumberish | null, ksuAmount?: null, ksuBonusAmount?: null, rKSUMinted?: null): UserLockedEventFilter;
        "UserUnlocked(address,uint256,uint256,uint256)"(user?: string | null, lockId?: BigNumberish | null, ksuAmount?: null, rKSUBurned?: null): UserUnlockedEventFilter;
        UserUnlocked(user?: string | null, lockId?: BigNumberish | null, ksuAmount?: null, rKSUBurned?: null): UserUnlockedEventFilter;
    };
    estimateGas: {
        addLockPeriod(lockPeriod: BigNumberish, rKSUMultiplier: BigNumberish, ksuBonusMultiplier: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<BigNumber>;
        approve(spender: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;
        claimFees(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        emergencyWithdraw(emergencyWithdrawInput: EmergencyWithdrawInputStruct[], receiver: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        emitFees(amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        lock(amount: BigNumberish, lockPeriod: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        lockDetails(lockPeriod: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        lockWithPermit(amount: BigNumberish, lockPeriod: BigNumberish, ksuPermit: IKSULocking.ERC20PermitPayloadStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        rewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;
        setKSULockBonus(ksuBonusTokens_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transfer(to: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        transferFrom(from: string, to: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unlock(amount: BigNumberish, userLockId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        userLock(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        userTotalDeposits(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        addLockPeriod(lockPeriod: BigNumberish, rKSUMultiplier: BigNumberish, ksuBonusMultiplier: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        allowance(owner: string, spender: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        approve(spender: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        balanceOf(account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        claimFees(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        emergencyWithdraw(emergencyWithdrawInput: EmergencyWithdrawInputStruct[], receiver: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        emitFees(amount: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        lock(amount: BigNumberish, lockPeriod: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        lockDetails(lockPeriod: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockWithPermit(amount: BigNumberish, lockPeriod: BigNumberish, ksuPermit: IKSULocking.ERC20PermitPayloadStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        rewards(user: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setKSULockBonus(ksuBonusTokens_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transfer(to: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        transferFrom(from: string, to: string, value: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unlock(amount: BigNumberish, userLockId: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        userLock(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        userTotalDeposits(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}