import { BN } from "@coral-xyz/anchor";
import { AccountMeta, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "./base";
import { WhirlpoolsPolicy } from "../deser/integrationPolicies";
type Numeric = BN | bigint | number;
export declare const ORCA_POSITION_METADATA_UPDATE_AUTHORITY: PublicKey;
export type OrcaAccountsType = {
    transferHookA: Record<string, never>;
} | {
    transferHookB: Record<string, never>;
} | {
    transferHookReward: Record<string, never>;
} | {
    transferHookInput: Record<string, never>;
} | {
    transferHookIntermediate: Record<string, never>;
} | {
    transferHookOutput: Record<string, never>;
} | {
    supplementalTickArrays: Record<string, never>;
} | {
    supplementalTickArraysOne: Record<string, never>;
} | {
    supplementalTickArraysTwo: Record<string, never>;
} | {
    transferHookDepositA: Record<string, never>;
} | {
    transferHookDepositB: Record<string, never>;
} | {
    transferHookWithdrawalA: Record<string, never>;
} | {
    transferHookWithdrawalB: Record<string, never>;
};
export type OrcaRemainingAccountsInfo = {
    slices: Array<{
        accountsType: OrcaAccountsType;
        length: number;
    }>;
};
export type OrcaPriceDeviationAccounts = {
    glamConfig?: PublicKey;
    tokenMintAOracle: PublicKey;
    tokenMintBOracle: PublicKey;
    solUsdOracle?: PublicKey;
    kaminoReserves?: PublicKey[];
};
export type OrcaPriceDeviationRemainingAccounts = {
    priceDeviationAccounts?: OrcaPriceDeviationAccounts;
};
export type OrcaV2RemainingAccounts = {
    remainingAccountsInfo?: OrcaRemainingAccountsInfo | null;
    remainingAccounts?: AccountMeta[];
};
export type OpenOrcaPositionWithTokenExtensionsParams = {
    tickLowerIndex: number;
    tickUpperIndex: number;
    withTokenMetadataExtension?: boolean;
};
export type OpenOrcaPositionWithTokenExtensionsAccounts = {
    whirlpool: PublicKey;
    positionMint: PublicKey;
    position?: PublicKey;
    positionTokenAccount?: PublicKey;
    metadataUpdateAuth?: PublicKey;
};
export type InitializeOrcaTickArrayParams = {
    startTickIndex: number;
};
export type IncreaseOrcaLiquidityV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
    liquidityAmount: Numeric;
    tokenMaxA: Numeric;
    tokenMaxB: Numeric;
};
export type DecreaseOrcaLiquidityV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
    liquidityAmount: Numeric;
    tokenMinA: Numeric;
    tokenMinB: Numeric;
};
export type IncreaseOrcaLiquidityByTokenAmountsMethod = {
    byTokenAmounts: {
        tokenMaxA: Numeric;
        tokenMaxB: Numeric;
        minSqrtPrice: Numeric;
        maxSqrtPrice: Numeric;
    };
};
export type IncreaseOrcaLiquidityByTokenAmountsV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
    method: IncreaseOrcaLiquidityByTokenAmountsMethod;
};
export type RepositionOrcaLiquidityMethod = {
    byLiquidity: {
        newLiquidityAmount: Numeric;
        existingRangeTokenMinA: Numeric;
        existingRangeTokenMinB: Numeric;
        newRangeTokenMaxA: Numeric;
        newRangeTokenMaxB: Numeric;
    };
};
export type RepositionOrcaLiquidityV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
    newTickLowerIndex: number;
    newTickUpperIndex: number;
    method: RepositionOrcaLiquidityMethod;
};
export type OrcaPositionAccounts = {
    whirlpool: PublicKey;
    position: PublicKey;
    positionMint: PublicKey;
    positionTokenAccount?: PublicKey;
};
export type OrcaUpdateFeesAndRewardsAccounts = {
    whirlpool: PublicKey;
    position: PublicKey;
    tickArrayLower: PublicKey;
    tickArrayUpper: PublicKey;
};
export type OrcaLiquidityV2Accounts = OrcaPositionAccounts & OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
    tokenMintA: PublicKey;
    tokenMintB: PublicKey;
    tokenVaultA: PublicKey;
    tokenVaultB: PublicKey;
    tickArrayLower: PublicKey;
    tickArrayUpper: PublicKey;
    tokenOwnerAccountA?: PublicKey;
    tokenOwnerAccountB?: PublicKey;
    tokenProgramA?: PublicKey;
    tokenProgramB?: PublicKey;
    memoProgram?: PublicKey;
};
export type InitializeOrcaTickArrayAccounts = {
    whirlpool: PublicKey;
    tickArray?: PublicKey;
};
export type RepositionOrcaLiquidityV2Accounts = Omit<OrcaLiquidityV2Accounts, "tickArrayLower" | "tickArrayUpper"> & {
    existingTickArrayLower: PublicKey;
    existingTickArrayUpper: PublicKey;
    newTickArrayLower: PublicKey;
    newTickArrayUpper: PublicKey;
};
export type CollectOrcaFeesV2Accounts = OrcaPositionAccounts & OrcaV2RemainingAccounts & {
    tokenMintA: PublicKey;
    tokenMintB: PublicKey;
    tokenOwnerAccountA?: PublicKey;
    tokenOwnerAccountB?: PublicKey;
    tokenVaultA: PublicKey;
    tokenVaultB: PublicKey;
    tokenProgramA?: PublicKey;
    tokenProgramB?: PublicKey;
    memoProgram?: PublicKey;
};
export type CollectOrcaRewardV2Accounts = OrcaPositionAccounts & OrcaV2RemainingAccounts & {
    rewardMint: PublicKey;
    rewardVault: PublicKey;
    rewardOwnerAccount?: PublicKey;
    rewardTokenProgram?: PublicKey;
    memoProgram?: PublicKey;
};
export type ParsedOrcaPosition = {
    whirlpool: PublicKey;
    positionMint: PublicKey;
    liquidity: bigint;
    tickLowerIndex: number;
    tickUpperIndex: number;
    rewardInfos: Array<{
        growthInsideCheckpoint: bigint;
        amountOwed: bigint;
    }>;
    rewardAmountsOwed: bigint[];
};
export type ParsedOrcaWhirlpool = {
    tokenMintA: PublicKey;
    tokenMintB: PublicKey;
    tickSpacing: number;
    liquidity: bigint;
    tickCurrentIndex: number;
    rewardLastUpdatedTimestamp: bigint;
    rewardInfos: Array<{
        mint: PublicKey;
        emissionsPerSecondX64: bigint;
        growthGlobalX64: bigint;
    }>;
};
export type ParsedOrcaTick = {
    rewardGrowthsOutside: bigint[];
};
export type OrcaWhirlpoolPricingAccounts = {
    numPositions: number;
    remainingAccounts: AccountMeta[];
    kaminoReserves: PublicKey[];
};
export declare function getOrcaPositionPda(positionMint: PublicKey, programId?: PublicKey): [PublicKey, number];
export declare function getOrcaTickArrayPda(whirlpool: PublicKey, startTickIndex: number, programId?: PublicKey): [PublicKey, number];
export declare function parseOrcaPosition(data: Buffer): ParsedOrcaPosition;
export declare function parseOrcaWhirlpool(data: Buffer): ParsedOrcaWhirlpool;
export declare function parseOrcaTickArrayTick(data: Buffer, expectedWhirlpool: PublicKey, expectedStartTickIndex: number, tickIndex: number, tickSpacing: number): ParsedOrcaTick;
export declare function getOrcaTickArrayStartIndex(tickIndex: number, tickSpacing: number): number;
export declare function deriveTickArrayForPosition(whirlpool: PublicKey, tickIndex: number, tickSpacing: number): PublicKey;
declare class TxBuilder extends BaseTxBuilder<OrcaWhirlpoolsClient> implements ProtocolPolicyTxBuilder<WhirlpoolsPolicy> {
    setPolicyIx(policy: WhirlpoolsPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
    setPolicyTx(policy: WhirlpoolsPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
    openPositionWithTokenExtensionsIx(params: OpenOrcaPositionWithTokenExtensionsParams, accounts: OpenOrcaPositionWithTokenExtensionsAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
    openPositionWithTokenExtensionsTx(params: OpenOrcaPositionWithTokenExtensionsParams, accounts: OpenOrcaPositionWithTokenExtensionsAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    initializeTickArrayIx(params: InitializeOrcaTickArrayParams, accounts: InitializeOrcaTickArrayAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
    initializeTickArrayTx(params: InitializeOrcaTickArrayParams, accounts: InitializeOrcaTickArrayAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    increaseLiquidityV2Ix(params: IncreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
    increaseLiquidityV2Tx(params: IncreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    increaseLiquidityByTokenAmountsV2Ix(params: IncreaseOrcaLiquidityByTokenAmountsV2Params, accounts: OrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
    increaseLiquidityByTokenAmountsV2Tx(params: IncreaseOrcaLiquidityByTokenAmountsV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    decreaseLiquidityV2Ix(params: DecreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
    decreaseLiquidityV2Tx(params: DecreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    repositionLiquidityV2Ix(params: RepositionOrcaLiquidityV2Params, accounts: RepositionOrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
    repositionLiquidityV2Tx(params: RepositionOrcaLiquidityV2Params, accounts: RepositionOrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    updateFeesAndRewardsIx(accounts: OrcaUpdateFeesAndRewardsAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
    updateFeesAndRewardsTx(accounts: OrcaUpdateFeesAndRewardsAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    collectFeesV2Ix(accounts: CollectOrcaFeesV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
    collectFeesV2Tx(accounts: CollectOrcaFeesV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    collectRewardV2Ix(rewardIndex: number, accounts: CollectOrcaRewardV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
    collectRewardV2Tx(rewardIndex: number, accounts: CollectOrcaRewardV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    closePositionWithTokenExtensionsIx(accounts: OrcaPositionAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
    closePositionWithTokenExtensionsTx(accounts: OrcaPositionAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
    private sharedBaseAccounts;
    private liquidityV2Accounts;
    private tokenPrograms;
    private tokenProgramForMint;
    private withRemainingAccounts;
    private priceDeviationAccountMetas;
    private withKaminoReserveRefreshTxOptions;
    private fetchAndParseKaminoReserves;
    private refreshKaminoReservesBatchIx;
}
export declare class OrcaWhirlpoolsClient implements ProtocolPolicyClient<WhirlpoolsPolicy> {
    readonly base: BaseClient;
    readonly txBuilder: TxBuilder;
    constructor(base: BaseClient);
    getIntegrationAuthorityPda(): PublicKey;
    getPositionPda(positionMint: PublicKey): [PublicKey, number];
    getTickArrayPda(whirlpool: PublicKey, startTickIndex: number): [PublicKey, number];
    getPositionTokenAta(positionMint: PublicKey): PublicKey;
    remainingAccountsForPricingWhirlpoolPositions(orcaPositions: PublicKey[]): Promise<OrcaWhirlpoolPricingAccounts | null>;
    fetchPolicy(): Promise<WhirlpoolsPolicy | null>;
    setPolicy(policy: WhirlpoolsPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
    openPositionWithTokenExtensions(params: OpenOrcaPositionWithTokenExtensionsParams, accounts: OpenOrcaPositionWithTokenExtensionsAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    initializeTickArray(params: InitializeOrcaTickArrayParams, accounts: InitializeOrcaTickArrayAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    increaseLiquidityV2(params: IncreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    increaseLiquidityByTokenAmountsV2(params: IncreaseOrcaLiquidityByTokenAmountsV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    decreaseLiquidityV2(params: DecreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    repositionLiquidityV2(params: RepositionOrcaLiquidityV2Params, accounts: RepositionOrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    updateFeesAndRewards(accounts: OrcaUpdateFeesAndRewardsAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    collectFeesV2(accounts: CollectOrcaFeesV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    collectRewardV2(rewardIndex: number, accounts: CollectOrcaRewardV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
    closePositionWithTokenExtensions(accounts: OrcaPositionAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
}
export {};