staking_contract

new staking_contract(options: AptosBindOptions): staking_contract;

getChainId(): string;

onEntryAddStake(
   func: (call: AddStakePayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, AddStakePayload>
): staking_contract;

onEntryCreateStakingContract(
   func: (call: CreateStakingContractPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, CreateStakingContractPayload>
): staking_contract;

onEntryDistribute(
   func: (call: DistributePayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, DistributePayload>
): staking_contract;

onEntryRequestCommission(
   func: (call: RequestCommissionPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, RequestCommissionPayload>
): staking_contract;

onEntryResetLockup(
   func: (call: ResetLockupPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, ResetLockupPayload>
): staking_contract;

onEntrySetBeneficiaryForOperator(
   func: (call: SetBeneficiaryForOperatorPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, SetBeneficiaryForOperatorPayload>
): staking_contract;

onEntrySwitchOperator(
   func: (call: SwitchOperatorPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, SwitchOperatorPayload>
): staking_contract;

onEntrySwitchOperatorWithSameCommission(
   func: (call: SwitchOperatorWithSameCommissionPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, SwitchOperatorWithSameCommissionPayload>
): staking_contract;

onEntryUnlockRewards(
   func: (call: UnlockRewardsPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UnlockRewardsPayload>
): staking_contract;

onEntryUnlockStake(
   func: (call: UnlockStakePayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UnlockStakePayload>
): staking_contract;

onEntryUpdateCommision(
   func: (call: UpdateCommisionPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UpdateCommisionPayload>
): staking_contract;

onEntryUpdateVoter(
   func: (call: UpdateVoterPayload, ctx: AptosContext) => void, 
   filter?: CallFilter, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UpdateVoterPayload>
): staking_contract;

onEvent(handler: (event: Event, ctx: AptosContext) => void, handlerOptions?: HandlerOptions<MoveFetchConfig, Event>): this;

onEventAddDistribution(
   func: (event: AddDistributionInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, AddDistributionInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventAddDistributionEvent(
   func: (event: AddDistributionEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, AddDistributionEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventAddStake(
   func: (event: AddStakeInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, AddStakeInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventAddStakeEvent(
   func: (event: AddStakeEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, AddStakeEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventCreateStakingContract(
   func: (event: CreateStakingContractInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, CreateStakingContractInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventCreateStakingContractEvent(
   func: (event: CreateStakingContractEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, CreateStakingContractEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventDistribute(
   func: (event: DistributeInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, DistributeInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventDistributeEvent(
   func: (event: DistributeEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, DistributeEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventRequestCommission(
   func: (event: RequestCommissionInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, RequestCommissionInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventRequestCommissionEvent(
   func: (event: RequestCommissionEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, RequestCommissionEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventResetLockup(
   func: (event: ResetLockupInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, ResetLockupInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventResetLockupEvent(
   func: (event: ResetLockupEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, ResetLockupEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventSetBeneficiaryForOperator(
   func: (event: SetBeneficiaryForOperatorInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, SetBeneficiaryForOperatorInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventStakingGroupUpdateCommissionEvent(
   func: (event: StakingGroupUpdateCommissionEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, StakingGroupUpdateCommissionEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventSwitchOperator(
   func: (event: SwitchOperatorInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, SwitchOperatorInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventSwitchOperatorEvent(
   func: (event: SwitchOperatorEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, SwitchOperatorEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventUnlockStake(
   func: (event: UnlockStakeInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UnlockStakeInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventUnlockStakeEvent(
   func: (event: UnlockStakeEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UnlockStakeEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventUpdateCommission(
   func: (event: UpdateCommissionInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UpdateCommissionInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventUpdateCommissionEvent(
   func: (event: UpdateCommissionEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UpdateCommissionEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventUpdateVoter(
   func: (event: UpdateVoterInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UpdateVoterInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onEventUpdateVoterEvent(
   func: (event: UpdateVoterEventInstance, ctx: AptosContext) => void, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UpdateVoterEventInstance>, 
   eventFilter?: Omit<EventFilter, "account" | "type">
): staking_contract;

onResourceChange<T>(
   handler: (changes: ResourceChange<T>[], ctx: AptosResourcesContext) => PromiseOrVoid, 
   typeDesc: 
  | string
  | TypeDescriptor<T>, 
   handlerOptions?: HandlerOptions<object, ResourceChange<T>[]>
): this;

onResourceChange<Descs extends readonly (
  | string
  | TypeDescriptor<any>)[]>(
   handler: (changes: ResourceChange<ExtractDescriptorType<Descs[number]>>[], ctx: AptosResourcesContext) => PromiseOrVoid, 
   typeDesc: [...Descs[]], 
   handlerOptions?: HandlerOptions<object, ResourceChange<ExtractDescriptorType<Descs[number]>>[]>
): this;

onTimeInterval(
   handler: (transaction: UserTransactionResponse, ctx: AptosContext) => PromiseOrVoid, 
   timeIntervalInMinutes?: number, 
   backfillTimeIntervalInMinutes?: number, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UserTransactionResponse>
): this;

onTransaction(
   handler: (transaction: UserTransactionResponse, ctx: AptosContext) => PromiseOrVoid, 
   transactionFilter?: object, 
   handleOptions?: HandlerOptions<MoveFetchConfig, UserTransactionResponse>
): this;

onVersionInterval(
   handler: (transaction: UserTransactionResponse, context: AptosContext) => PromiseOrVoid, 
   versionInterval?: number, 
   backfillVersionInterval?: number, 
   handlerOptions?: HandlerOptions<MoveFetchConfig, UserTransactionResponse>
): this;

static bind(options?: Partial<AptosBindOptions>): staking_contract;