/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
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 declare namespace BaseTxAuthDataVerifier {
  export type TxAuthDataStruct = {
    chainID: BigNumberish;
    nonce: BigNumberish;
    blockExpiration: BigNumberish;
    contractAddress: string;
    userAddress: string;
    functionCallData: BytesLike;
  };

  export type TxAuthDataStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    string,
    string,
    string
  ] & {
    chainID: BigNumber;
    nonce: BigNumber;
    blockExpiration: BigNumber;
    contractAddress: string;
    userAddress: string;
    functionCallData: string;
  };
}

export interface IKasuAllowListAbiInterface extends utils.Interface {
  functions: {
    "allowList(address)": FunctionFragment;
    "allowUser(address)": FunctionFragment;
    "blockList(address)": FunctionFragment;
    "blockUser(address)": FunctionFragment;
    "disallowUser(address)": FunctionFragment;
    "getMessageHash((uint256,uint256,uint256,address,address,bytes))": FunctionFragment;
    "initialize(address,address)": FunctionFragment;
    "nonces(address)": FunctionFragment;
    "setNexeraIDSigner(address)": FunctionFragment;
    "txAuthDataSignerAddress()": FunctionFragment;
    "txAuthDataUserNonce(address)": FunctionFragment;
    "unblockUser(address)": FunctionFragment;
    "verifyUserKyc(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "allowList"
      | "allowUser"
      | "blockList"
      | "blockUser"
      | "disallowUser"
      | "getMessageHash"
      | "initialize"
      | "nonces"
      | "setNexeraIDSigner"
      | "txAuthDataSignerAddress"
      | "txAuthDataUserNonce"
      | "unblockUser"
      | "verifyUserKyc"
  ): FunctionFragment;

  encodeFunctionData(functionFragment: "allowList", values: [string]): string;
  encodeFunctionData(functionFragment: "allowUser", values: [string]): string;
  encodeFunctionData(functionFragment: "blockList", values: [string]): string;
  encodeFunctionData(functionFragment: "blockUser", values: [string]): string;
  encodeFunctionData(
    functionFragment: "disallowUser",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getMessageHash",
    values: [BaseTxAuthDataVerifier.TxAuthDataStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string]
  ): string;
  encodeFunctionData(functionFragment: "nonces", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setNexeraIDSigner",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "txAuthDataSignerAddress",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "txAuthDataUserNonce",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "unblockUser", values: [string]): string;
  encodeFunctionData(
    functionFragment: "verifyUserKyc",
    values: [string]
  ): string;

  decodeFunctionResult(functionFragment: "allowList", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "allowUser", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "blockList", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "blockUser", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "disallowUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getMessageHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setNexeraIDSigner",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "txAuthDataSignerAddress",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "txAuthDataUserNonce",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "unblockUser",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "verifyUserKyc",
    data: BytesLike
  ): Result;

  events: {
    "Initialized(uint64)": EventFragment;
    "NexeraIDSignatureVerified(uint256,uint256,uint256,address,address,bytes)": EventFragment;
    "SignerChanged(address)": EventFragment;
    "UserAddedInAllowList(address)": EventFragment;
    "UserBlockedFromAllowList(address)": EventFragment;
    "UserRemovedFromAllowList(address)": EventFragment;
    "UserUnblockedFromAllowList(address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "NexeraIDSignatureVerified"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SignerChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserAddedInAllowList"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserBlockedFromAllowList"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserRemovedFromAllowList"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserUnblockedFromAllowList"): EventFragment;
}

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

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface NexeraIDSignatureVerifiedEventObject {
  chainID: BigNumber;
  nonce: BigNumber;
  blockExpiration: BigNumber;
  contractAddress: string;
  userAddress: string;
  functionCallData: string;
}
export type NexeraIDSignatureVerifiedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, string, string, string],
  NexeraIDSignatureVerifiedEventObject
>;

export type NexeraIDSignatureVerifiedEventFilter =
  TypedEventFilter<NexeraIDSignatureVerifiedEvent>;

export interface SignerChangedEventObject {
  newSigner: string;
}
export type SignerChangedEvent = TypedEvent<[string], SignerChangedEventObject>;

export type SignerChangedEventFilter = TypedEventFilter<SignerChangedEvent>;

export interface UserAddedInAllowListEventObject {
  user: string;
}
export type UserAddedInAllowListEvent = TypedEvent<
  [string],
  UserAddedInAllowListEventObject
>;

export type UserAddedInAllowListEventFilter =
  TypedEventFilter<UserAddedInAllowListEvent>;

export interface UserBlockedFromAllowListEventObject {
  user: string;
}
export type UserBlockedFromAllowListEvent = TypedEvent<
  [string],
  UserBlockedFromAllowListEventObject
>;

export type UserBlockedFromAllowListEventFilter =
  TypedEventFilter<UserBlockedFromAllowListEvent>;

export interface UserRemovedFromAllowListEventObject {
  user: string;
}
export type UserRemovedFromAllowListEvent = TypedEvent<
  [string],
  UserRemovedFromAllowListEventObject
>;

export type UserRemovedFromAllowListEventFilter =
  TypedEventFilter<UserRemovedFromAllowListEvent>;

export interface UserUnblockedFromAllowListEventObject {
  user: string;
}
export type UserUnblockedFromAllowListEvent = TypedEvent<
  [string],
  UserUnblockedFromAllowListEventObject
>;

export type UserUnblockedFromAllowListEventFilter =
  TypedEventFilter<UserUnblockedFromAllowListEvent>;

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

  interface: IKasuAllowListAbiInterface;

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

    allowUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    blockList(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;

    blockUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    disallowUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    getMessageHash(
      _txAuthData: BaseTxAuthDataVerifier.TxAuthDataStruct,
      overrides?: CallOverrides
    ): Promise<[string]>;

    initialize(
      lendingPoolManager_: string,
      signer_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    nonces(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    setNexeraIDSigner(
      signer_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    txAuthDataUserNonce(
      user: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    unblockUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    verifyUserKyc(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;
  };

  allowList(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  allowUser(
    user: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  blockList(arg0: string, overrides?: CallOverrides): Promise<boolean>;

  blockUser(
    user: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  disallowUser(
    user: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  getMessageHash(
    _txAuthData: BaseTxAuthDataVerifier.TxAuthDataStruct,
    overrides?: CallOverrides
  ): Promise<string>;

  initialize(
    lendingPoolManager_: string,
    signer_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  nonces(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

  setNexeraIDSigner(
    signer_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  txAuthDataUserNonce(
    user: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  unblockUser(
    user: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  verifyUserKyc(
    user: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  callStatic: {
    allowList(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    allowUser(user: string, overrides?: CallOverrides): Promise<void>;

    blockList(arg0: string, overrides?: CallOverrides): Promise<boolean>;

    blockUser(user: string, overrides?: CallOverrides): Promise<void>;

    disallowUser(user: string, overrides?: CallOverrides): Promise<void>;

    getMessageHash(
      _txAuthData: BaseTxAuthDataVerifier.TxAuthDataStruct,
      overrides?: CallOverrides
    ): Promise<string>;

    initialize(
      lendingPoolManager_: string,
      signer_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    nonces(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    setNexeraIDSigner(
      signer_: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    txAuthDataUserNonce(
      user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    unblockUser(user: string, overrides?: CallOverrides): Promise<void>;

    verifyUserKyc(user: string, overrides?: CallOverrides): Promise<boolean>;
  };

  filters: {
    "Initialized(uint64)"(version?: null): InitializedEventFilter;
    Initialized(version?: null): InitializedEventFilter;

    "NexeraIDSignatureVerified(uint256,uint256,uint256,address,address,bytes)"(
      chainID?: null,
      nonce?: null,
      blockExpiration?: null,
      contractAddress?: null,
      userAddress?: null,
      functionCallData?: null
    ): NexeraIDSignatureVerifiedEventFilter;
    NexeraIDSignatureVerified(
      chainID?: null,
      nonce?: null,
      blockExpiration?: null,
      contractAddress?: null,
      userAddress?: null,
      functionCallData?: null
    ): NexeraIDSignatureVerifiedEventFilter;

    "SignerChanged(address)"(
      newSigner?: string | null
    ): SignerChangedEventFilter;
    SignerChanged(newSigner?: string | null): SignerChangedEventFilter;

    "UserAddedInAllowList(address)"(
      user?: string | null
    ): UserAddedInAllowListEventFilter;
    UserAddedInAllowList(user?: string | null): UserAddedInAllowListEventFilter;

    "UserBlockedFromAllowList(address)"(
      user?: string | null
    ): UserBlockedFromAllowListEventFilter;
    UserBlockedFromAllowList(
      user?: string | null
    ): UserBlockedFromAllowListEventFilter;

    "UserRemovedFromAllowList(address)"(
      user?: string | null
    ): UserRemovedFromAllowListEventFilter;
    UserRemovedFromAllowList(
      user?: string | null
    ): UserRemovedFromAllowListEventFilter;

    "UserUnblockedFromAllowList(address)"(
      user?: string | null
    ): UserUnblockedFromAllowListEventFilter;
    UserUnblockedFromAllowList(
      user?: string | null
    ): UserUnblockedFromAllowListEventFilter;
  };

  estimateGas: {
    allowList(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    allowUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    blockList(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    blockUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    disallowUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    getMessageHash(
      _txAuthData: BaseTxAuthDataVerifier.TxAuthDataStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      lendingPoolManager_: string,
      signer_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    nonces(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;

    setNexeraIDSigner(
      signer_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    txAuthDataUserNonce(
      user: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    unblockUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    verifyUserKyc(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    allowList(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    allowUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    blockList(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    blockUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    disallowUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    getMessageHash(
      _txAuthData: BaseTxAuthDataVerifier.TxAuthDataStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      lendingPoolManager_: string,
      signer_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    nonces(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setNexeraIDSigner(
      signer_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    txAuthDataUserNonce(
      user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    unblockUser(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    verifyUserKyc(
      user: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;
  };
}