new SolanaStakingClient(__namedParameters): SolanaStakingClient;

claimRewards(data, extParams): Promise<ITransactionResult>;

clawback(data, extParams): Promise<ITransactionResult>;

closeRewardEntry(data, extParams): Promise<ITransactionResult>;

closeStakeEntry(data, extParams): Promise<{
  ixs: TransactionInstruction[];
  txId: string;
}>;

createFundDelegate(data, extParams): Promise<CreateFundDelegateResult>;

createRewardEntry(data, extParams): Promise<ITransactionResult>;

createRewardPool(data, extParams): Promise<CreationResult>;

createStakePool(data, extParams): Promise<CreationResult>;

decode<ProgramName, DecodingProgram, DerivedIdl, AccountName, DecodedAccount>(
   programKey, 
   accountName, 
   accInfo): DecodedAccount;

execute(ixs, extParams): Promise<{
  signature: string;
}>;

fundPool(data, extParams): Promise<ITransactionResult>;

getCommitment(): Commitment;

getCurrentProgramId(programKey): PublicKey;

getDefaultFeeValue(): Promise<{
  authority: PublicKey;
  buffer1: number[];
  buffer2: number[];
  buffer3: number[];
  streamflowFee: BN;
}>;

getDiscriminator<ProgramName, DecodingProgram, DerivedIdl, AccountName>(programKey, accountName): number[];

getFee(target): Promise<
  | {
  buffer: number[];
  streamflowFee: BN;
}
  | {
  authority: PublicKey;
  buffer1: number[];
  buffer2: number[];
  buffer3: number[];
  streamflowFee: BN;
}>;

getFeeValueIfExists(target): Promise<{
  buffer: number[];
  streamflowFee: BN;
}>;

getStakeEntry(id): Promise<{
  amount: BN;
  authority: PublicKey;
  autoUnstake: boolean;
  buffer: number[];
  closedTs: BN;
  createdTs: BN;
  duration: BN;
  effectiveAmount: BN;
  isSponsored: boolean;
  nonce: number;
  payer: PublicKey;
  priorTotalEffectiveStake: BN;
  stakePool: PublicKey;
  unstakeTs: BN;
}>;

getStakePool(id): Promise<{
  authority: PublicKey;
  autoUnstake: boolean;
  buffer: number[];
  bump: number;
  creator: PublicKey;
  expiryTs: BN;
  freezeStakeMint: boolean;
  isTotalStakeCapped: boolean;
  maxDuration: BN;
  maxWeight: BN;
  minDuration: BN;
  mint: PublicKey;
  minWeight: BN;
  nonce: number;
  permissionless: boolean;
  remainingTotalStake: BN;
  stakeMint: PublicKey;
  totalEffectiveStake: BN;
  totalStake: BN;
  unstakePeriod: BN;
  vault: PublicKey;
}>;

prepareClaimRewardsInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareClawbackInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareCloseRewardEntryInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareCloseStakeEntryInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareCreateFundDelegateInstructions(__namedParameters, extParams): Promise<CreateFundDelegatePrepareResult>;

prepareCreateRewardEntryInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareCreateRewardPoolInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
  publicKey: PublicKey;
}>;

prepareCreateStakePoolInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
  publicKey: PublicKey;
}>;

prepareFundPoolInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareStakeAndCreateEntriesInstructions(data, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareStakeInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareUnstakeAndClaimInstructions(data, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareUnstakeAndCloseInstructions(data, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareUnstakeInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

prepareUpdateRewardPoolInstructions(__namedParameters, extParams): Promise<{
  ixs: TransactionInstruction[];
}>;

searchRewardEntries(criteria): Promise<ProgramAccount<{
  accountedAmount: BN;
  buffer: number[];
  claimedAmount: BN;
  createdTs: BN;
  isSponsored: boolean;
  lastAccountedTs: BN;
  lastRewardAmount: BN;
  lastRewardPeriod: BN;
  rewardPool: PublicKey;
  stakeEntry: PublicKey;
}>[]>;

searchRewardPools(criteria?): Promise<ProgramAccount<{
  authority: PublicKey;
  buffer: number[];
  bump: number;
  claimedAmount: BN;
  clawedBackTs: BN;
  createdTs: BN;
  creator: PublicKey;
  fundedAmount: BN;
  lastAmountUpdateTs: BN;
  lastClaimPeriod: BN;
  lastPeriodUpdateTs: BN;
  lastRewardAmount: BN;
  lastRewardPeriod: BN;
  mint: PublicKey;
  nonce: number;
  permissionless: boolean;
  rewardAmount: BN;
  rewardPeriod: BN;
  stakePool: PublicKey;
  vault: PublicKey;
}>[]>;

searchStakeEntries(criteria?): Promise<ProgramAccount<{
  amount: BN;
  authority: PublicKey;
  autoUnstake: boolean;
  buffer: number[];
  closedTs: BN;
  createdTs: BN;
  duration: BN;
  effectiveAmount: BN;
  isSponsored: boolean;
  nonce: number;
  payer: PublicKey;
  priorTotalEffectiveStake: BN;
  stakePool: PublicKey;
  unstakeTs: BN;
}>[]>;

searchStakePools(criteria?): Promise<ProgramAccount<{
  authority: PublicKey;
  autoUnstake: boolean;
  buffer: number[];
  bump: number;
  creator: PublicKey;
  expiryTs: BN;
  freezeStakeMint: boolean;
  isTotalStakeCapped: boolean;
  maxDuration: BN;
  maxWeight: BN;
  minDuration: BN;
  mint: PublicKey;
  minWeight: BN;
  nonce: number;
  permissionless: boolean;
  remainingTotalStake: BN;
  stakeMint: PublicKey;
  totalEffectiveStake: BN;
  totalStake: BN;
  unstakePeriod: BN;
  vault: PublicKey;
}>[]>;

stake(data, extParams): Promise<ITransactionResult>;

stakeAndCreateEntries(data, extParams): Promise<ITransactionResult>;

unstake(data, extParams): Promise<ITransactionResult>;

unstakeAndClaim(data, extParams): Promise<ITransactionResult>;

unstakeAndClose(data, extParams): Promise<ITransactionResult>;

updateRewardPool(data, extParams): Promise<{
  ixs: TransactionInstruction[];
  txId: string;
}>;