/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
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 TetherPublicLockInterface extends utils.Interface {
  functions: {
    "DEFAULT_ADMIN_ROLE()": FunctionFragment;
    "KEY_GRANTER_ROLE()": FunctionFragment;
    "LOCK_MANAGER_ROLE()": FunctionFragment;
    "addKeyGranter(address)": FunctionFragment;
    "addLockManager(address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "approveBeneficiary(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "beneficiary()": FunctionFragment;
    "cancelAndRefund(uint256)": FunctionFragment;
    "disableLock()": FunctionFragment;
    "expirationDuration()": FunctionFragment;
    "expireAndRefundFor(address,uint256)": FunctionFragment;
    "freeTrialLength()": FunctionFragment;
    "gasRefundValue()": FunctionFragment;
    "getApproved(uint256)": FunctionFragment;
    "getCancelAndRefundValueFor(address)": FunctionFragment;
    "getHasValidKey(address)": FunctionFragment;
    "getRoleAdmin(bytes32)": FunctionFragment;
    "getTokenIdFor(address)": FunctionFragment;
    "grantKeys(address[],uint256[],address[])": FunctionFragment;
    "grantRole(bytes32,address)": FunctionFragment;
    "hasRole(bytes32,address)": FunctionFragment;
    "initialize(address,uint256,address,uint256,uint256,string)": FunctionFragment;
    "isAlive()": FunctionFragment;
    "isApprovedForAll(address,address)": FunctionFragment;
    "isKeyGranter(address)": FunctionFragment;
    "isLockManager(address)": FunctionFragment;
    "keyManagerOf(uint256)": FunctionFragment;
    "keyPrice()": FunctionFragment;
    "maxNumberOfKeys()": FunctionFragment;
    "name()": FunctionFragment;
    "ownerOf(uint256)": FunctionFragment;
    "publicLockVersion()": FunctionFragment;
    "purchase(uint256,address,address,address,bytes)": FunctionFragment;
    "purchasePriceFor(address,address,bytes)": FunctionFragment;
    "refundPenaltyBasisPoints()": FunctionFragment;
    "renounceLockManager()": FunctionFragment;
    "renounceRole(bytes32,address)": FunctionFragment;
    "revokeKeyGranter(address)": FunctionFragment;
    "revokeRole(bytes32,address)": FunctionFragment;
    "safeTransferFrom(address,address,uint256)": FunctionFragment;
    "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment;
    "setApprovalForAll(address,bool)": FunctionFragment;
    "setBaseTokenURI(string)": FunctionFragment;
    "setGasRefundValue(uint256)": FunctionFragment;
    "setKeyManagerOf(uint256,address)": FunctionFragment;
    "setMaxNumberOfKeys(uint256)": FunctionFragment;
    "setTetherContractAddress(address)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "symbol()": FunctionFragment;
    "tetherContractAddress()": FunctionFragment;
    "tokenAddress()": FunctionFragment;
    "tokenByIndex(uint256)": FunctionFragment;
    "tokenOfOwnerByIndex(address,uint256)": FunctionFragment;
    "tokenURI(uint256)": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "updateBeneficiary(address)": FunctionFragment;
    "updateKeyPricing(uint256,address)": FunctionFragment;
    "updateLockName(string)": FunctionFragment;
    "updateLockSymbol(string)": FunctionFragment;
    "updateRefundPenalty(uint256,uint256)": FunctionFragment;
    "withdraw(address,uint256)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "DEFAULT_ADMIN_ROLE"
      | "KEY_GRANTER_ROLE"
      | "LOCK_MANAGER_ROLE"
      | "addKeyGranter"
      | "addLockManager"
      | "approve"
      | "approveBeneficiary"
      | "balanceOf"
      | "beneficiary"
      | "cancelAndRefund"
      | "disableLock"
      | "expirationDuration"
      | "expireAndRefundFor"
      | "freeTrialLength"
      | "gasRefundValue"
      | "getApproved"
      | "getCancelAndRefundValueFor"
      | "getHasValidKey"
      | "getRoleAdmin"
      | "getTokenIdFor"
      | "grantKeys"
      | "grantRole"
      | "hasRole"
      | "initialize"
      | "isAlive"
      | "isApprovedForAll"
      | "isKeyGranter"
      | "isLockManager"
      | "keyManagerOf"
      | "keyPrice"
      | "maxNumberOfKeys"
      | "name"
      | "ownerOf"
      | "publicLockVersion"
      | "purchase"
      | "purchasePriceFor"
      | "refundPenaltyBasisPoints"
      | "renounceLockManager"
      | "renounceRole"
      | "revokeKeyGranter"
      | "revokeRole"
      | "safeTransferFrom(address,address,uint256)"
      | "safeTransferFrom(address,address,uint256,bytes)"
      | "setApprovalForAll"
      | "setBaseTokenURI"
      | "setGasRefundValue"
      | "setKeyManagerOf"
      | "setMaxNumberOfKeys"
      | "setTetherContractAddress"
      | "supportsInterface"
      | "symbol"
      | "tetherContractAddress"
      | "tokenAddress"
      | "tokenByIndex"
      | "tokenOfOwnerByIndex"
      | "tokenURI"
      | "totalSupply"
      | "transfer"
      | "transferFrom"
      | "updateBeneficiary"
      | "updateKeyPricing"
      | "updateLockName"
      | "updateLockSymbol"
      | "updateRefundPenalty"
      | "withdraw"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "KEY_GRANTER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "LOCK_MANAGER_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addKeyGranter",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "addLockManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "approveBeneficiary",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "balanceOf",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "beneficiary",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cancelAndRefund",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "disableLock",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "expirationDuration",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "expireAndRefundFor",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "freeTrialLength",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "gasRefundValue",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getApproved",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "getCancelAndRefundValueFor",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getHasValidKey",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleAdmin",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokenIdFor",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "grantKeys",
    values: [
      PromiseOrValue<string>[],
      PromiseOrValue<BigNumberish>[],
      PromiseOrValue<string>[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "grantRole",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "hasRole",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>
    ]
  ): string;
  encodeFunctionData(functionFragment: "isAlive", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "isApprovedForAll",
    values: [PromiseOrValue<string>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isKeyGranter",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "isLockManager",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "keyManagerOf",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(functionFragment: "keyPrice", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "maxNumberOfKeys",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "ownerOf",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "publicLockVersion",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "purchase",
    values: [
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "purchasePriceFor",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "refundPenaltyBasisPoints",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceLockManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceRole",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeKeyGranter",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRole",
    values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "safeTransferFrom(address,address,uint256)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "safeTransferFrom(address,address,uint256,bytes)",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>,
      PromiseOrValue<BytesLike>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "setApprovalForAll",
    values: [PromiseOrValue<string>, PromiseOrValue<boolean>]
  ): string;
  encodeFunctionData(
    functionFragment: "setBaseTokenURI",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setGasRefundValue",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setKeyManagerOf",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "setMaxNumberOfKeys",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "setTetherContractAddress",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [PromiseOrValue<BytesLike>]
  ): string;
  encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "tetherContractAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "tokenAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "tokenByIndex",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenOfOwnerByIndex",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "tokenURI",
    values: [PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [
      PromiseOrValue<string>,
      PromiseOrValue<string>,
      PromiseOrValue<BigNumberish>
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "updateBeneficiary",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "updateKeyPricing",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "updateLockName",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "updateLockSymbol",
    values: [PromiseOrValue<string>]
  ): string;
  encodeFunctionData(
    functionFragment: "updateRefundPenalty",
    values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]
  ): string;
  encodeFunctionData(
    functionFragment: "withdraw",
    values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]
  ): string;

  decodeFunctionResult(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "KEY_GRANTER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "LOCK_MANAGER_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addKeyGranter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "addLockManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "approveBeneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "beneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cancelAndRefund",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "disableLock",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "expirationDuration",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "expireAndRefundFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "freeTrialLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "gasRefundValue",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getApproved",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCancelAndRefundValueFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getHasValidKey",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTokenIdFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "grantKeys", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "isAlive", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "isApprovedForAll",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isKeyGranter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "isLockManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "keyManagerOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "keyPrice", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "maxNumberOfKeys",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "publicLockVersion",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "purchase", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "purchasePriceFor",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "refundPenaltyBasisPoints",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceLockManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "revokeKeyGranter",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "safeTransferFrom(address,address,uint256)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "safeTransferFrom(address,address,uint256,bytes)",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setApprovalForAll",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setBaseTokenURI",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setGasRefundValue",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setKeyManagerOf",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setMaxNumberOfKeys",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setTetherContractAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "tetherContractAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenByIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "tokenOfOwnerByIndex",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateBeneficiary",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateKeyPricing",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateLockName",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateLockSymbol",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateRefundPenalty",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "ApprovalForAll(address,address,bool)": EventFragment;
    "CancelKey(uint256,address,address,uint256)": EventFragment;
    "ContractDeployed(address)": EventFragment;
    "Disable()": EventFragment;
    "GasRefunded(address,uint256,address)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "KeyGranterAdded(address)": EventFragment;
    "KeyGranterRemoved(address)": EventFragment;
    "KeyManagerChanged(uint256,address)": EventFragment;
    "LockManagerAdded(address)": EventFragment;
    "LockManagerRemoved(address)": EventFragment;
    "NewLockSymbol(string)": EventFragment;
    "PricingChanged(uint256,uint256,address,address)": EventFragment;
    "RefundPenaltyChanged(uint256,uint256)": EventFragment;
    "RenewKeyPurchase(address,uint256)": EventFragment;
    "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
    "RoleGranted(bytes32,address,address)": EventFragment;
    "RoleRevoked(bytes32,address,address)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "TransferFeeChanged(uint256)": EventFragment;
    "UnlockCallFailed(address,address)": EventFragment;
    "Withdrawal(address,address,address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CancelKey"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ContractDeployed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Disable"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "GasRefunded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeyGranterAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeyGranterRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "KeyManagerChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockManagerAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockManagerRemoved"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NewLockSymbol"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "PricingChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RefundPenaltyChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RenewKeyPurchase"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "TransferFeeChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UnlockCallFailed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment;
}

export interface ApprovalEventObject {
  owner: string;
  approved: string;
  tokenId: BigNumber;
}
export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  ApprovalEventObject
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface ApprovalForAllEventObject {
  owner: string;
  operator: string;
  approved: boolean;
}
export type ApprovalForAllEvent = TypedEvent<
  [string, string, boolean],
  ApprovalForAllEventObject
>;

export type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;

export interface CancelKeyEventObject {
  tokenId: BigNumber;
  owner: string;
  sendTo: string;
  refund: BigNumber;
}
export type CancelKeyEvent = TypedEvent<
  [BigNumber, string, string, BigNumber],
  CancelKeyEventObject
>;

export type CancelKeyEventFilter = TypedEventFilter<CancelKeyEvent>;

export interface ContractDeployedEventObject {
  contractAddress: string;
}
export type ContractDeployedEvent = TypedEvent<
  [string],
  ContractDeployedEventObject
>;

export type ContractDeployedEventFilter =
  TypedEventFilter<ContractDeployedEvent>;

export interface DisableEventObject {}
export type DisableEvent = TypedEvent<[], DisableEventObject>;

export type DisableEventFilter = TypedEventFilter<DisableEvent>;

export interface GasRefundedEventObject {
  receiver: string;
  refundedAmount: BigNumber;
  tokenAddress: string;
}
export type GasRefundedEvent = TypedEvent<
  [string, BigNumber, string],
  GasRefundedEventObject
>;

export type GasRefundedEventFilter = TypedEventFilter<GasRefundedEvent>;

export interface InitializedEventObject {
  version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface KeyGranterAddedEventObject {
  account: string;
}
export type KeyGranterAddedEvent = TypedEvent<
  [string],
  KeyGranterAddedEventObject
>;

export type KeyGranterAddedEventFilter = TypedEventFilter<KeyGranterAddedEvent>;

export interface KeyGranterRemovedEventObject {
  account: string;
}
export type KeyGranterRemovedEvent = TypedEvent<
  [string],
  KeyGranterRemovedEventObject
>;

export type KeyGranterRemovedEventFilter =
  TypedEventFilter<KeyGranterRemovedEvent>;

export interface KeyManagerChangedEventObject {
  _tokenId: BigNumber;
  _newManager: string;
}
export type KeyManagerChangedEvent = TypedEvent<
  [BigNumber, string],
  KeyManagerChangedEventObject
>;

export type KeyManagerChangedEventFilter =
  TypedEventFilter<KeyManagerChangedEvent>;

export interface LockManagerAddedEventObject {
  account: string;
}
export type LockManagerAddedEvent = TypedEvent<
  [string],
  LockManagerAddedEventObject
>;

export type LockManagerAddedEventFilter =
  TypedEventFilter<LockManagerAddedEvent>;

export interface LockManagerRemovedEventObject {
  account: string;
}
export type LockManagerRemovedEvent = TypedEvent<
  [string],
  LockManagerRemovedEventObject
>;

export type LockManagerRemovedEventFilter =
  TypedEventFilter<LockManagerRemovedEvent>;

export interface NewLockSymbolEventObject {
  symbol: string;
}
export type NewLockSymbolEvent = TypedEvent<[string], NewLockSymbolEventObject>;

export type NewLockSymbolEventFilter = TypedEventFilter<NewLockSymbolEvent>;

export interface PricingChangedEventObject {
  oldKeyPrice: BigNumber;
  keyPrice: BigNumber;
  oldTokenAddress: string;
  tokenAddress: string;
}
export type PricingChangedEvent = TypedEvent<
  [BigNumber, BigNumber, string, string],
  PricingChangedEventObject
>;

export type PricingChangedEventFilter = TypedEventFilter<PricingChangedEvent>;

export interface RefundPenaltyChangedEventObject {
  freeTrialLength: BigNumber;
  refundPenaltyBasisPoints: BigNumber;
}
export type RefundPenaltyChangedEvent = TypedEvent<
  [BigNumber, BigNumber],
  RefundPenaltyChangedEventObject
>;

export type RefundPenaltyChangedEventFilter =
  TypedEventFilter<RefundPenaltyChangedEvent>;

export interface RenewKeyPurchaseEventObject {
  owner: string;
  newExpiration: BigNumber;
}
export type RenewKeyPurchaseEvent = TypedEvent<
  [string, BigNumber],
  RenewKeyPurchaseEventObject
>;

export type RenewKeyPurchaseEventFilter =
  TypedEventFilter<RenewKeyPurchaseEvent>;

export interface RoleAdminChangedEventObject {
  role: string;
  previousAdminRole: string;
  newAdminRole: string;
}
export type RoleAdminChangedEvent = TypedEvent<
  [string, string, string],
  RoleAdminChangedEventObject
>;

export type RoleAdminChangedEventFilter =
  TypedEventFilter<RoleAdminChangedEvent>;

export interface RoleGrantedEventObject {
  role: string;
  account: string;
  sender: string;
}
export type RoleGrantedEvent = TypedEvent<
  [string, string, string],
  RoleGrantedEventObject
>;

export type RoleGrantedEventFilter = TypedEventFilter<RoleGrantedEvent>;

export interface RoleRevokedEventObject {
  role: string;
  account: string;
  sender: string;
}
export type RoleRevokedEvent = TypedEvent<
  [string, string, string],
  RoleRevokedEventObject
>;

export type RoleRevokedEventFilter = TypedEventFilter<RoleRevokedEvent>;

export interface TransferEventObject {
  from: string;
  to: string;
  tokenId: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

export interface TransferFeeChangedEventObject {
  transferFeeBasisPoints: BigNumber;
}
export type TransferFeeChangedEvent = TypedEvent<
  [BigNumber],
  TransferFeeChangedEventObject
>;

export type TransferFeeChangedEventFilter =
  TypedEventFilter<TransferFeeChangedEvent>;

export interface UnlockCallFailedEventObject {
  lockAddress: string;
  unlockAddress: string;
}
export type UnlockCallFailedEvent = TypedEvent<
  [string, string],
  UnlockCallFailedEventObject
>;

export type UnlockCallFailedEventFilter =
  TypedEventFilter<UnlockCallFailedEvent>;

export interface WithdrawalEventObject {
  sender: string;
  tokenAddress: string;
  beneficiary: string;
  amount: BigNumber;
}
export type WithdrawalEvent = TypedEvent<
  [string, string, string, BigNumber],
  WithdrawalEventObject
>;

export type WithdrawalEventFilter = TypedEventFilter<WithdrawalEvent>;

export interface TetherPublicLock extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: TetherPublicLockInterface;

  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: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;

    KEY_GRANTER_ROLE(overrides?: CallOverrides): Promise<[string]>;

    LOCK_MANAGER_ROLE(overrides?: CallOverrides): Promise<[string]>;

    addKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    addLockManager(
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    approve(
      _approved: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    approveBeneficiary(
      _spender: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    balanceOf(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    beneficiary(overrides?: CallOverrides): Promise<[string]>;

    cancelAndRefund(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    disableLock(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    expirationDuration(overrides?: CallOverrides): Promise<[BigNumber]>;

    expireAndRefundFor(
      _keyOwner: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    freeTrialLength(overrides?: CallOverrides): Promise<[BigNumber]>;

    gasRefundValue(
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { _refundValue: BigNumber }>;

    getApproved(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getCancelAndRefundValueFor(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { refund: BigNumber }>;

    getHasValidKey(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean] & { isValid: boolean }>;

    getRoleAdmin(
      role: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getTokenIdFor(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    grantKeys(
      _recipients: PromiseOrValue<string>[],
      _expirationTimestamps: PromiseOrValue<BigNumberish>[],
      _keyManagers: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    grantRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    hasRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    initialize(
      _lockCreator: PromiseOrValue<string>,
      _expirationDuration: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      _keyPrice: PromiseOrValue<BigNumberish>,
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      _lockName: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    isAlive(overrides?: CallOverrides): Promise<[boolean]>;

    isApprovedForAll(
      _owner: PromiseOrValue<string>,
      _operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    isLockManager(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    keyManagerOf(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    keyPrice(overrides?: CallOverrides): Promise<[BigNumber]>;

    maxNumberOfKeys(overrides?: CallOverrides): Promise<[BigNumber]>;

    name(overrides?: CallOverrides): Promise<[string]>;

    ownerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    publicLockVersion(overrides?: CallOverrides): Promise<[number]>;

    purchase(
      _value: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _keyManager: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    purchasePriceFor(
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { minKeyPrice: BigNumber }>;

    refundPenaltyBasisPoints(overrides?: CallOverrides): Promise<[BigNumber]>;

    renounceLockManager(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    renounceRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    revokeKeyGranter(
      _granter: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    revokeRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "safeTransferFrom(address,address,uint256)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setApprovalForAll(
      _to: PromiseOrValue<string>,
      _approved: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setBaseTokenURI(
      _baseTokenURI: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setGasRefundValue(
      _refundValue: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setKeyManagerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      _keyManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setMaxNumberOfKeys(
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    setTetherContractAddress(
      _tetherContractAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    supportsInterface(
      interfaceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    symbol(overrides?: CallOverrides): Promise<[string]>;

    tetherContractAddress(overrides?: CallOverrides): Promise<[string]>;

    tokenAddress(overrides?: CallOverrides): Promise<[string]>;

    tokenByIndex(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    tokenOfOwnerByIndex(
      _keyOwner: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    tokenURI(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<[string]>;

    totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;

    transfer(
      _to: PromiseOrValue<string>,
      _value: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    transferFrom(
      _from: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    updateBeneficiary(
      _beneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    updateKeyPricing(
      _keyPrice: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    updateLockName(
      _lockName: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    updateLockSymbol(
      _lockSymbol: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    updateRefundPenalty(
      _freeTrialLength: PromiseOrValue<BigNumberish>,
      _refundPenaltyBasisPoints: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;

    withdraw(
      _tokenAddress: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<ContractTransaction>;
  };

  DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;

  KEY_GRANTER_ROLE(overrides?: CallOverrides): Promise<string>;

  LOCK_MANAGER_ROLE(overrides?: CallOverrides): Promise<string>;

  addKeyGranter(
    account: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  addLockManager(
    account: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  approve(
    _approved: PromiseOrValue<string>,
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  approveBeneficiary(
    _spender: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  balanceOf(
    _keyOwner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  beneficiary(overrides?: CallOverrides): Promise<string>;

  cancelAndRefund(
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  disableLock(
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  expirationDuration(overrides?: CallOverrides): Promise<BigNumber>;

  expireAndRefundFor(
    _keyOwner: PromiseOrValue<string>,
    amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  freeTrialLength(overrides?: CallOverrides): Promise<BigNumber>;

  gasRefundValue(overrides?: CallOverrides): Promise<BigNumber>;

  getApproved(
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  getCancelAndRefundValueFor(
    _keyOwner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getHasValidKey(
    _keyOwner: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  getRoleAdmin(
    role: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<string>;

  getTokenIdFor(
    _account: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  grantKeys(
    _recipients: PromiseOrValue<string>[],
    _expirationTimestamps: PromiseOrValue<BigNumberish>[],
    _keyManagers: PromiseOrValue<string>[],
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  grantRole(
    role: PromiseOrValue<BytesLike>,
    account: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  hasRole(
    role: PromiseOrValue<BytesLike>,
    account: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  initialize(
    _lockCreator: PromiseOrValue<string>,
    _expirationDuration: PromiseOrValue<BigNumberish>,
    _tokenAddress: PromiseOrValue<string>,
    _keyPrice: PromiseOrValue<BigNumberish>,
    _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
    _lockName: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  isAlive(overrides?: CallOverrides): Promise<boolean>;

  isApprovedForAll(
    _owner: PromiseOrValue<string>,
    _operator: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isKeyGranter(
    account: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  isLockManager(
    account: PromiseOrValue<string>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  keyManagerOf(
    arg0: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  keyPrice(overrides?: CallOverrides): Promise<BigNumber>;

  maxNumberOfKeys(overrides?: CallOverrides): Promise<BigNumber>;

  name(overrides?: CallOverrides): Promise<string>;

  ownerOf(
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  publicLockVersion(overrides?: CallOverrides): Promise<number>;

  purchase(
    _value: PromiseOrValue<BigNumberish>,
    _recipient: PromiseOrValue<string>,
    _referrer: PromiseOrValue<string>,
    _keyManager: PromiseOrValue<string>,
    _data: PromiseOrValue<BytesLike>,
    overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  purchasePriceFor(
    _recipient: PromiseOrValue<string>,
    _referrer: PromiseOrValue<string>,
    _data: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  refundPenaltyBasisPoints(overrides?: CallOverrides): Promise<BigNumber>;

  renounceLockManager(
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  renounceRole(
    role: PromiseOrValue<BytesLike>,
    account: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  revokeKeyGranter(
    _granter: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  revokeRole(
    role: PromiseOrValue<BytesLike>,
    account: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "safeTransferFrom(address,address,uint256)"(
    _from: PromiseOrValue<string>,
    _to: PromiseOrValue<string>,
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  "safeTransferFrom(address,address,uint256,bytes)"(
    _from: PromiseOrValue<string>,
    _to: PromiseOrValue<string>,
    _tokenId: PromiseOrValue<BigNumberish>,
    _data: PromiseOrValue<BytesLike>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setApprovalForAll(
    _to: PromiseOrValue<string>,
    _approved: PromiseOrValue<boolean>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setBaseTokenURI(
    _baseTokenURI: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setGasRefundValue(
    _refundValue: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setKeyManagerOf(
    _tokenId: PromiseOrValue<BigNumberish>,
    _keyManager: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setMaxNumberOfKeys(
    _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  setTetherContractAddress(
    _tetherContractAddress: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  supportsInterface(
    interfaceId: PromiseOrValue<BytesLike>,
    overrides?: CallOverrides
  ): Promise<boolean>;

  symbol(overrides?: CallOverrides): Promise<string>;

  tetherContractAddress(overrides?: CallOverrides): Promise<string>;

  tokenAddress(overrides?: CallOverrides): Promise<string>;

  tokenByIndex(
    _index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  tokenOfOwnerByIndex(
    _keyOwner: PromiseOrValue<string>,
    _index: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  tokenURI(
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: CallOverrides
  ): Promise<string>;

  totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

  transfer(
    _to: PromiseOrValue<string>,
    _value: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  transferFrom(
    _from: PromiseOrValue<string>,
    _recipient: PromiseOrValue<string>,
    _tokenId: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  updateBeneficiary(
    _beneficiary: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  updateKeyPricing(
    _keyPrice: PromiseOrValue<BigNumberish>,
    _tokenAddress: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  updateLockName(
    _lockName: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  updateLockSymbol(
    _lockSymbol: PromiseOrValue<string>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  updateRefundPenalty(
    _freeTrialLength: PromiseOrValue<BigNumberish>,
    _refundPenaltyBasisPoints: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  withdraw(
    _tokenAddress: PromiseOrValue<string>,
    _amount: PromiseOrValue<BigNumberish>,
    overrides?: Overrides & { from?: PromiseOrValue<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;

    KEY_GRANTER_ROLE(overrides?: CallOverrides): Promise<string>;

    LOCK_MANAGER_ROLE(overrides?: CallOverrides): Promise<string>;

    addKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    addLockManager(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    approve(
      _approved: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    approveBeneficiary(
      _spender: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    balanceOf(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    beneficiary(overrides?: CallOverrides): Promise<string>;

    cancelAndRefund(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    disableLock(overrides?: CallOverrides): Promise<void>;

    expirationDuration(overrides?: CallOverrides): Promise<BigNumber>;

    expireAndRefundFor(
      _keyOwner: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    freeTrialLength(overrides?: CallOverrides): Promise<BigNumber>;

    gasRefundValue(overrides?: CallOverrides): Promise<BigNumber>;

    getApproved(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    getCancelAndRefundValueFor(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getHasValidKey(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    getRoleAdmin(
      role: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<string>;

    getTokenIdFor(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    grantKeys(
      _recipients: PromiseOrValue<string>[],
      _expirationTimestamps: PromiseOrValue<BigNumberish>[],
      _keyManagers: PromiseOrValue<string>[],
      overrides?: CallOverrides
    ): Promise<void>;

    grantRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    hasRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    initialize(
      _lockCreator: PromiseOrValue<string>,
      _expirationDuration: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      _keyPrice: PromiseOrValue<BigNumberish>,
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      _lockName: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    isAlive(overrides?: CallOverrides): Promise<boolean>;

    isApprovedForAll(
      _owner: PromiseOrValue<string>,
      _operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    isLockManager(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    keyManagerOf(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    keyPrice(overrides?: CallOverrides): Promise<BigNumber>;

    maxNumberOfKeys(overrides?: CallOverrides): Promise<BigNumber>;

    name(overrides?: CallOverrides): Promise<string>;

    ownerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    publicLockVersion(overrides?: CallOverrides): Promise<number>;

    purchase(
      _value: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _keyManager: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    purchasePriceFor(
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    refundPenaltyBasisPoints(overrides?: CallOverrides): Promise<BigNumber>;

    renounceLockManager(overrides?: CallOverrides): Promise<void>;

    renounceRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    revokeKeyGranter(
      _granter: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    revokeRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    "safeTransferFrom(address,address,uint256)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<void>;

    setApprovalForAll(
      _to: PromiseOrValue<string>,
      _approved: PromiseOrValue<boolean>,
      overrides?: CallOverrides
    ): Promise<void>;

    setBaseTokenURI(
      _baseTokenURI: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setGasRefundValue(
      _refundValue: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setKeyManagerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      _keyManager: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    setMaxNumberOfKeys(
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    setTetherContractAddress(
      _tetherContractAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    supportsInterface(
      interfaceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    symbol(overrides?: CallOverrides): Promise<string>;

    tetherContractAddress(overrides?: CallOverrides): Promise<string>;

    tokenAddress(overrides?: CallOverrides): Promise<string>;

    tokenByIndex(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenOfOwnerByIndex(
      _keyOwner: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenURI(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<string>;

    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

    transfer(
      _to: PromiseOrValue<string>,
      _value: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      _from: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    updateBeneficiary(
      _beneficiary: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    updateKeyPricing(
      _keyPrice: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    updateLockName(
      _lockName: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    updateLockSymbol(
      _lockSymbol: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<void>;

    updateRefundPenalty(
      _freeTrialLength: PromiseOrValue<BigNumberish>,
      _refundPenaltyBasisPoints: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;

    withdraw(
      _tokenAddress: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "Approval(address,address,uint256)"(
      owner?: PromiseOrValue<string> | null,
      approved?: PromiseOrValue<string> | null,
      tokenId?: PromiseOrValue<BigNumberish> | null
    ): ApprovalEventFilter;
    Approval(
      owner?: PromiseOrValue<string> | null,
      approved?: PromiseOrValue<string> | null,
      tokenId?: PromiseOrValue<BigNumberish> | null
    ): ApprovalEventFilter;

    "ApprovalForAll(address,address,bool)"(
      owner?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      approved?: null
    ): ApprovalForAllEventFilter;
    ApprovalForAll(
      owner?: PromiseOrValue<string> | null,
      operator?: PromiseOrValue<string> | null,
      approved?: null
    ): ApprovalForAllEventFilter;

    "CancelKey(uint256,address,address,uint256)"(
      tokenId?: PromiseOrValue<BigNumberish> | null,
      owner?: PromiseOrValue<string> | null,
      sendTo?: PromiseOrValue<string> | null,
      refund?: null
    ): CancelKeyEventFilter;
    CancelKey(
      tokenId?: PromiseOrValue<BigNumberish> | null,
      owner?: PromiseOrValue<string> | null,
      sendTo?: PromiseOrValue<string> | null,
      refund?: null
    ): CancelKeyEventFilter;

    "ContractDeployed(address)"(
      contractAddress?: PromiseOrValue<string> | null
    ): ContractDeployedEventFilter;
    ContractDeployed(
      contractAddress?: PromiseOrValue<string> | null
    ): ContractDeployedEventFilter;

    "Disable()"(): DisableEventFilter;
    Disable(): DisableEventFilter;

    "GasRefunded(address,uint256,address)"(
      receiver?: PromiseOrValue<string> | null,
      refundedAmount?: null,
      tokenAddress?: null
    ): GasRefundedEventFilter;
    GasRefunded(
      receiver?: PromiseOrValue<string> | null,
      refundedAmount?: null,
      tokenAddress?: null
    ): GasRefundedEventFilter;

    "Initialized(uint8)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "KeyGranterAdded(address)"(
      account?: PromiseOrValue<string> | null
    ): KeyGranterAddedEventFilter;
    KeyGranterAdded(
      account?: PromiseOrValue<string> | null
    ): KeyGranterAddedEventFilter;

    "KeyGranterRemoved(address)"(
      account?: PromiseOrValue<string> | null
    ): KeyGranterRemovedEventFilter;
    KeyGranterRemoved(
      account?: PromiseOrValue<string> | null
    ): KeyGranterRemovedEventFilter;

    "KeyManagerChanged(uint256,address)"(
      _tokenId?: PromiseOrValue<BigNumberish> | null,
      _newManager?: PromiseOrValue<string> | null
    ): KeyManagerChangedEventFilter;
    KeyManagerChanged(
      _tokenId?: PromiseOrValue<BigNumberish> | null,
      _newManager?: PromiseOrValue<string> | null
    ): KeyManagerChangedEventFilter;

    "LockManagerAdded(address)"(
      account?: PromiseOrValue<string> | null
    ): LockManagerAddedEventFilter;
    LockManagerAdded(
      account?: PromiseOrValue<string> | null
    ): LockManagerAddedEventFilter;

    "LockManagerRemoved(address)"(
      account?: PromiseOrValue<string> | null
    ): LockManagerRemovedEventFilter;
    LockManagerRemoved(
      account?: PromiseOrValue<string> | null
    ): LockManagerRemovedEventFilter;

    "NewLockSymbol(string)"(symbol?: null): NewLockSymbolEventFilter;
    NewLockSymbol(symbol?: null): NewLockSymbolEventFilter;

    "PricingChanged(uint256,uint256,address,address)"(
      oldKeyPrice?: null,
      keyPrice?: null,
      oldTokenAddress?: null,
      tokenAddress?: null
    ): PricingChangedEventFilter;
    PricingChanged(
      oldKeyPrice?: null,
      keyPrice?: null,
      oldTokenAddress?: null,
      tokenAddress?: null
    ): PricingChangedEventFilter;

    "RefundPenaltyChanged(uint256,uint256)"(
      freeTrialLength?: null,
      refundPenaltyBasisPoints?: null
    ): RefundPenaltyChangedEventFilter;
    RefundPenaltyChanged(
      freeTrialLength?: null,
      refundPenaltyBasisPoints?: null
    ): RefundPenaltyChangedEventFilter;

    "RenewKeyPurchase(address,uint256)"(
      owner?: PromiseOrValue<string> | null,
      newExpiration?: null
    ): RenewKeyPurchaseEventFilter;
    RenewKeyPurchase(
      owner?: PromiseOrValue<string> | null,
      newExpiration?: null
    ): RenewKeyPurchaseEventFilter;

    "RoleAdminChanged(bytes32,bytes32,bytes32)"(
      role?: PromiseOrValue<BytesLike> | null,
      previousAdminRole?: PromiseOrValue<BytesLike> | null,
      newAdminRole?: PromiseOrValue<BytesLike> | null
    ): RoleAdminChangedEventFilter;
    RoleAdminChanged(
      role?: PromiseOrValue<BytesLike> | null,
      previousAdminRole?: PromiseOrValue<BytesLike> | null,
      newAdminRole?: PromiseOrValue<BytesLike> | null
    ): RoleAdminChangedEventFilter;

    "RoleGranted(bytes32,address,address)"(
      role?: PromiseOrValue<BytesLike> | null,
      account?: PromiseOrValue<string> | null,
      sender?: PromiseOrValue<string> | null
    ): RoleGrantedEventFilter;
    RoleGranted(
      role?: PromiseOrValue<BytesLike> | null,
      account?: PromiseOrValue<string> | null,
      sender?: PromiseOrValue<string> | null
    ): RoleGrantedEventFilter;

    "RoleRevoked(bytes32,address,address)"(
      role?: PromiseOrValue<BytesLike> | null,
      account?: PromiseOrValue<string> | null,
      sender?: PromiseOrValue<string> | null
    ): RoleRevokedEventFilter;
    RoleRevoked(
      role?: PromiseOrValue<BytesLike> | null,
      account?: PromiseOrValue<string> | null,
      sender?: PromiseOrValue<string> | null
    ): RoleRevokedEventFilter;

    "Transfer(address,address,uint256)"(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      tokenId?: PromiseOrValue<BigNumberish> | null
    ): TransferEventFilter;
    Transfer(
      from?: PromiseOrValue<string> | null,
      to?: PromiseOrValue<string> | null,
      tokenId?: PromiseOrValue<BigNumberish> | null
    ): TransferEventFilter;

    "TransferFeeChanged(uint256)"(
      transferFeeBasisPoints?: null
    ): TransferFeeChangedEventFilter;
    TransferFeeChanged(
      transferFeeBasisPoints?: null
    ): TransferFeeChangedEventFilter;

    "UnlockCallFailed(address,address)"(
      lockAddress?: PromiseOrValue<string> | null,
      unlockAddress?: null
    ): UnlockCallFailedEventFilter;
    UnlockCallFailed(
      lockAddress?: PromiseOrValue<string> | null,
      unlockAddress?: null
    ): UnlockCallFailedEventFilter;

    "Withdrawal(address,address,address,uint256)"(
      sender?: PromiseOrValue<string> | null,
      tokenAddress?: PromiseOrValue<string> | null,
      beneficiary?: PromiseOrValue<string> | null,
      amount?: null
    ): WithdrawalEventFilter;
    Withdrawal(
      sender?: PromiseOrValue<string> | null,
      tokenAddress?: PromiseOrValue<string> | null,
      beneficiary?: PromiseOrValue<string> | null,
      amount?: null
    ): WithdrawalEventFilter;
  };

  estimateGas: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;

    KEY_GRANTER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;

    LOCK_MANAGER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;

    addKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    addLockManager(
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    approve(
      _approved: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    approveBeneficiary(
      _spender: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    balanceOf(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    beneficiary(overrides?: CallOverrides): Promise<BigNumber>;

    cancelAndRefund(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    disableLock(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    expirationDuration(overrides?: CallOverrides): Promise<BigNumber>;

    expireAndRefundFor(
      _keyOwner: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    freeTrialLength(overrides?: CallOverrides): Promise<BigNumber>;

    gasRefundValue(overrides?: CallOverrides): Promise<BigNumber>;

    getApproved(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getCancelAndRefundValueFor(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getHasValidKey(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRoleAdmin(
      role: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenIdFor(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    grantKeys(
      _recipients: PromiseOrValue<string>[],
      _expirationTimestamps: PromiseOrValue<BigNumberish>[],
      _keyManagers: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    grantRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    hasRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      _lockCreator: PromiseOrValue<string>,
      _expirationDuration: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      _keyPrice: PromiseOrValue<BigNumberish>,
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      _lockName: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    isAlive(overrides?: CallOverrides): Promise<BigNumber>;

    isApprovedForAll(
      _owner: PromiseOrValue<string>,
      _operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    isLockManager(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    keyManagerOf(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    keyPrice(overrides?: CallOverrides): Promise<BigNumber>;

    maxNumberOfKeys(overrides?: CallOverrides): Promise<BigNumber>;

    name(overrides?: CallOverrides): Promise<BigNumber>;

    ownerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    publicLockVersion(overrides?: CallOverrides): Promise<BigNumber>;

    purchase(
      _value: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _keyManager: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    purchasePriceFor(
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    refundPenaltyBasisPoints(overrides?: CallOverrides): Promise<BigNumber>;

    renounceLockManager(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    renounceRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    revokeKeyGranter(
      _granter: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    revokeRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "safeTransferFrom(address,address,uint256)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setApprovalForAll(
      _to: PromiseOrValue<string>,
      _approved: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setBaseTokenURI(
      _baseTokenURI: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setGasRefundValue(
      _refundValue: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setKeyManagerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      _keyManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setMaxNumberOfKeys(
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    setTetherContractAddress(
      _tetherContractAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    supportsInterface(
      interfaceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    symbol(overrides?: CallOverrides): Promise<BigNumber>;

    tetherContractAddress(overrides?: CallOverrides): Promise<BigNumber>;

    tokenAddress(overrides?: CallOverrides): Promise<BigNumber>;

    tokenByIndex(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenOfOwnerByIndex(
      _keyOwner: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    tokenURI(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;

    transfer(
      _to: PromiseOrValue<string>,
      _value: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    transferFrom(
      _from: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    updateBeneficiary(
      _beneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    updateKeyPricing(
      _keyPrice: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    updateLockName(
      _lockName: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    updateLockSymbol(
      _lockSymbol: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    updateRefundPenalty(
      _freeTrialLength: PromiseOrValue<BigNumberish>,
      _refundPenaltyBasisPoints: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;

    withdraw(
      _tokenAddress: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    DEFAULT_ADMIN_ROLE(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    KEY_GRANTER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    LOCK_MANAGER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    addKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    addLockManager(
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    approve(
      _approved: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    approveBeneficiary(
      _spender: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    balanceOf(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    beneficiary(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    cancelAndRefund(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    disableLock(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    expirationDuration(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    expireAndRefundFor(
      _keyOwner: PromiseOrValue<string>,
      amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    freeTrialLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    gasRefundValue(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getApproved(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getCancelAndRefundValueFor(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getHasValidKey(
      _keyOwner: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRoleAdmin(
      role: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokenIdFor(
      _account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    grantKeys(
      _recipients: PromiseOrValue<string>[],
      _expirationTimestamps: PromiseOrValue<BigNumberish>[],
      _keyManagers: PromiseOrValue<string>[],
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    grantRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    hasRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      _lockCreator: PromiseOrValue<string>,
      _expirationDuration: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      _keyPrice: PromiseOrValue<BigNumberish>,
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      _lockName: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    isAlive(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    isApprovedForAll(
      _owner: PromiseOrValue<string>,
      _operator: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isKeyGranter(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    isLockManager(
      account: PromiseOrValue<string>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    keyManagerOf(
      arg0: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    keyPrice(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    maxNumberOfKeys(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    ownerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    publicLockVersion(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    purchase(
      _value: PromiseOrValue<BigNumberish>,
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _keyManager: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: PayableOverrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    purchasePriceFor(
      _recipient: PromiseOrValue<string>,
      _referrer: PromiseOrValue<string>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    refundPenaltyBasisPoints(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    renounceLockManager(
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    renounceRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    revokeKeyGranter(
      _granter: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    revokeRole(
      role: PromiseOrValue<BytesLike>,
      account: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "safeTransferFrom(address,address,uint256)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    "safeTransferFrom(address,address,uint256,bytes)"(
      _from: PromiseOrValue<string>,
      _to: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      _data: PromiseOrValue<BytesLike>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setApprovalForAll(
      _to: PromiseOrValue<string>,
      _approved: PromiseOrValue<boolean>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setBaseTokenURI(
      _baseTokenURI: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setGasRefundValue(
      _refundValue: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setKeyManagerOf(
      _tokenId: PromiseOrValue<BigNumberish>,
      _keyManager: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setMaxNumberOfKeys(
      _maxNumberOfKeys: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    setTetherContractAddress(
      _tetherContractAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    supportsInterface(
      interfaceId: PromiseOrValue<BytesLike>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    tetherContractAddress(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    tokenAddress(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    tokenByIndex(
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    tokenOfOwnerByIndex(
      _keyOwner: PromiseOrValue<string>,
      _index: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    tokenURI(
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    transfer(
      _to: PromiseOrValue<string>,
      _value: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    transferFrom(
      _from: PromiseOrValue<string>,
      _recipient: PromiseOrValue<string>,
      _tokenId: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    updateBeneficiary(
      _beneficiary: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    updateKeyPricing(
      _keyPrice: PromiseOrValue<BigNumberish>,
      _tokenAddress: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    updateLockName(
      _lockName: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    updateLockSymbol(
      _lockSymbol: PromiseOrValue<string>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    updateRefundPenalty(
      _freeTrialLength: PromiseOrValue<BigNumberish>,
      _refundPenaltyBasisPoints: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;

    withdraw(
      _tokenAddress: PromiseOrValue<string>,
      _amount: PromiseOrValue<BigNumberish>,
      overrides?: Overrides & { from?: PromiseOrValue<string> }
    ): Promise<PopulatedTransaction>;
  };
}