import { AddressLookupTableAccount, Connection, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
import { PROTOCOL_ACCOUNT_DISCRIMINATORS, PROTOCOL_INSTRUCTION_ACCOUNTS, PROTOCOL_INSTRUCTION_DISCRIMINATORS, PROTOCOL_PROGRAM_ID, type ProtocolInstructionAccount, type ProtocolInstructionName } from './generated/protocol_contract.js';
import type { BuildInstructionParams, BuildTransactionParams, GenericInstructionAccounts, ProtocolAccountName, ProtocolClient, PublicKeyish } from './generated/protocol_types.js';
import { getProgramId } from './protocol_seeds.js';
export declare const UNSAFE_CUSTOM_PROGRAM_ID_ENV = "OMEGAX_SDK_UNSAFE_ALLOW_CUSTOM_PROGRAM_ID";
export declare const PROTOCOL_IDL_VERSION: string;
export { CLAIM_ATTESTATION_DECISION_ABSTAIN, CLAIM_ATTESTATION_DECISION_REQUEST_REVIEW, CLAIM_ATTESTATION_DECISION_SUPPORT_APPROVE, CLAIM_ATTESTATION_DECISION_SUPPORT_DENY, } from './protocol_models.js';
export declare function getProtocolIdl(): {
    address: string;
    metadata: {
        name: string;
        version: string;
        spec: string;
        description: string;
    };
    instructions: ({
        name: string;
        discriminator: number[];
        accounts: ({
            name: string;
            writable: boolean;
            signer: boolean;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            pda: {
                seeds: {
                    kind: string;
                    value: number[];
                }[];
            };
            writable?: undefined;
            signer?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            signer?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            address: string;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
        docs?: undefined;
    } | {
        name: string;
        docs: string[];
        discriminator: number[];
        accounts: ({
            name: string;
            writable: boolean;
            signer: boolean;
            pda?: undefined;
            docs?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            writable?: undefined;
            signer?: undefined;
            docs?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                })[];
            };
            writable?: undefined;
            signer?: undefined;
            docs?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            docs: string[];
            optional: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                })[];
            };
            writable?: undefined;
            signer?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            docs?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            address: string;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
            docs?: undefined;
            optional?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
    } | {
        name: string;
        discriminator: number[];
        accounts: ({
            name: string;
            writable: boolean;
            signer: boolean;
            pda?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                })[];
            };
            writable?: undefined;
            signer?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                })[];
            };
            signer?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            optional: boolean;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            optional: boolean;
            signer?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            address: string;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
            optional?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
        docs?: undefined;
    } | {
        name: string;
        discriminator: number[];
        accounts: ({
            name: string;
            writable: boolean;
            signer: boolean;
            pda?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            writable?: undefined;
            signer?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            optional: boolean;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            optional?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            optional: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            address?: undefined;
        } | {
            name: string;
            signer: boolean;
            optional: boolean;
            writable?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            address: string;
            writable?: undefined;
            signer?: undefined;
            pda?: undefined;
            optional?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
        docs?: undefined;
    } | {
        name: string;
        discriminator: number[];
        accounts: ({
            name: string;
            signer: boolean;
            pda?: undefined;
            writable?: undefined;
            optional?: undefined;
            docs?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            writable?: undefined;
            optional?: undefined;
            docs?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            optional?: undefined;
            docs?: undefined;
        } | {
            name: string;
            writable: boolean;
            optional: boolean;
            signer?: undefined;
            pda?: undefined;
            docs?: undefined;
        } | {
            name: string;
            docs: string[];
            writable: boolean;
            optional: boolean;
            signer?: undefined;
            pda?: undefined;
        } | {
            name: string;
            docs: string[];
            optional: boolean;
            signer?: undefined;
            pda?: undefined;
            writable?: undefined;
        } | {
            name: string;
            signer?: undefined;
            pda?: undefined;
            writable?: undefined;
            optional?: undefined;
            docs?: undefined;
        } | {
            name: string;
            writable: boolean;
            signer?: undefined;
            pda?: undefined;
            optional?: undefined;
            docs?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
        docs?: undefined;
    } | {
        name: string;
        discriminator: number[];
        accounts: ({
            name: string;
            signer: boolean;
            pda?: undefined;
            writable?: undefined;
            optional?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            writable?: undefined;
            optional?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            optional?: undefined;
        } | {
            name: string;
            writable: boolean;
            optional: boolean;
            signer?: undefined;
            pda?: undefined;
        } | {
            name: string;
            writable: boolean;
            optional: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
        } | {
            name: string;
            optional: boolean;
            signer?: undefined;
            pda?: undefined;
            writable?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
        docs?: undefined;
    } | {
        name: string;
        docs: string[];
        discriminator: number[];
        accounts: ({
            name: string;
            signer: boolean;
            pda?: undefined;
            writable?: undefined;
            address?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            writable?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            address?: undefined;
        } | {
            name: string;
            writable: boolean;
            signer?: undefined;
            pda?: undefined;
            address?: undefined;
        } | {
            name: string;
            address: string;
            signer?: undefined;
            pda?: undefined;
            writable?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
    } | {
        name: string;
        docs: string[];
        discriminator: number[];
        accounts: ({
            name: string;
            signer: boolean;
            pda?: undefined;
            writable?: undefined;
        } | {
            name: string;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
            writable?: undefined;
        } | {
            name: string;
            writable: boolean;
            pda: {
                seeds: ({
                    kind: string;
                    value: number[];
                    path?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    value?: undefined;
                    account?: undefined;
                } | {
                    kind: string;
                    path: string;
                    account: string;
                    value?: undefined;
                })[];
            };
            signer?: undefined;
        } | {
            name: string;
            signer?: undefined;
            pda?: undefined;
            writable?: undefined;
        } | {
            name: string;
            writable: boolean;
            signer?: undefined;
            pda?: undefined;
        })[];
        args: {
            name: string;
            type: {
                defined: {
                    name: string;
                };
            };
        }[];
    })[];
    accounts: {
        name: string;
        discriminator: number[];
    }[];
    events: {
        name: string;
        discriminator: number[];
    }[];
    errors: {
        code: number;
        name: string;
        msg: string;
    }[];
    types: ({
        name: string;
        type: {
            kind: string;
            fields: ({
                name: string;
                type: string;
            } | {
                name: string;
                type: {
                    defined: {
                        name: string;
                    };
                };
            })[];
        };
    } | {
        name: string;
        type: {
            kind: string;
            fields: ({
                name: string;
                type: string;
                docs?: undefined;
            } | {
                name: string;
                docs: string[];
                type: string;
            })[];
        };
    } | {
        name: string;
        type: {
            kind: string;
            fields: ({
                name: string;
                type: string;
            } | {
                name: string;
                type: {
                    array: (number | {
                        array: (string | number)[];
                    })[];
                };
            })[];
        };
    } | {
        name: string;
        type: {
            kind: string;
            fields: ({
                name: string;
                type: string;
            } | {
                name: string;
                type: {
                    vec: {
                        array: (string | number)[];
                    };
                };
            })[];
        };
    } | {
        name: string;
        type: {
            kind: string;
            fields: ({
                name: string;
                type: {
                    array: (string | number)[];
                    vec?: undefined;
                };
            } | {
                name: string;
                type: {
                    vec: string;
                    array?: undefined;
                };
            } | {
                name: string;
                type: string;
            })[];
        };
    })[];
};
export declare function listProtocolInstructionNames(): ProtocolInstructionName[];
export declare function listProtocolInstructionAccounts(instructionName: ProtocolInstructionName): ProtocolInstructionAccount[];
export declare function listProtocolAccountNames(): ProtocolAccountName[];
export declare function accountExists(connection: Connection, address: PublicKeyish): Promise<boolean>;
export declare function decodeProtocolAccount<T = Record<string, unknown>>(accountName: ProtocolAccountName, data: Buffer | Uint8Array): T;
export declare function buildProtocolInstruction(params: BuildInstructionParams<Record<string, unknown>, GenericInstructionAccounts> & {
    instructionName: ProtocolInstructionName;
    unsafeAllowCustomProgramId?: boolean;
}): TransactionInstruction;
export declare function buildProtocolTransaction(params: BuildTransactionParams<Record<string, unknown>, GenericInstructionAccounts> & {
    instructionName: ProtocolInstructionName;
    unsafeAllowCustomProgramId?: boolean;
}): Transaction;
export type ProtocolInstructionAccountInput = {
    pubkey?: PublicKeyish | null;
    isSigner?: boolean;
    isWritable?: boolean;
};
export type SettlementOutflowAccounts = {
    memberPositionAddress: PublicKeyish;
    reserveAssetRailAddress?: PublicKeyish | null;
    vaultTokenAccountAddress: PublicKeyish;
    recipientTokenAccountAddress: PublicKeyish;
    tokenProgramId: PublicKeyish;
    poolOracleFeeVaultAddress?: PublicKeyish | null;
    poolOraclePolicyAddress?: PublicKeyish | null;
    oracleFeeAttestationAddress?: PublicKeyish | null;
};
export declare function buildInitializeProtocolGovernanceTx(params: {
    governanceAuthority: PublicKeyish;
    recentBlockhash: string;
    protocolFeeBps: number;
    emergencyPaused: boolean;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildAcceptProtocolGovernanceAuthorityTx(params: {
    pendingAuthority: PublicKeyish;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildCancelProtocolGovernanceAuthorityTransferTx(params: {
    authority: PublicKeyish;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildCreateReserveDomainTx(params: {
    authority: PublicKeyish;
    recentBlockhash: string;
    domainId: string;
    displayName: string;
    domainAdmin?: PublicKeyish | null;
    settlementMode: number;
    legalStructureHashHex?: string | null;
    complianceBaselineHashHex?: string | null;
    allowedRailMask: number;
    pauseFlags: number;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildCreateDomainAssetVaultTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    vaultTokenAccountAddress?: PublicKeyish;
    tokenProgram?: PublicKeyish;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildConfigureReserveAssetRailTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    assetMint: PublicKeyish;
    assetSymbol: string;
    oracleAuthority?: PublicKeyish | null;
    role: number;
    payoutPriority: number;
    oracleSource: number;
    oracleFeedIdHex?: string | null;
    maxStalenessSeconds: bigint;
    maxConfidenceBps: number;
    haircutBps: number;
    maxExposureBps: number;
    depositEnabled: boolean;
    payoutEnabled: boolean;
    capacityEnabled: boolean;
    active: boolean;
    reasonHashHex?: string | null;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildPublishReserveAssetRailPriceTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    assetMint: PublicKeyish;
    priceUsd1e8: bigint;
    confidenceBps: number;
    publishedAtTs: bigint;
    proofHashHex?: string | null;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildCreatePolicySeriesTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    seriesId: string;
    displayName: string;
    metadataUri: string;
    mode: number;
    status: number;
    adjudicationMode: number;
    termsHashHex?: string | null;
    pricingHashHex?: string | null;
    payoutHashHex?: string | null;
    reserveModelHashHex?: string | null;
    evidenceRequirementsHashHex?: string | null;
    comparabilityHashHex?: string | null;
    policyOverridesHashHex?: string | null;
    cycleSeconds: bigint;
    termsVersion: number;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildInitializeSeriesReserveLedgerTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    policySeriesAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildOpenFundingLineTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    lineId: string;
    policySeriesAddress?: PublicKeyish | null;
    lineType: number;
    fundingPriority: number;
    committedAmount: bigint;
    capsHashHex?: string | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildFundSponsorBudgetTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    sourceTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    policySeriesAddress?: PublicKeyish | null;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildRecordPremiumPaymentTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    sourceTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    policySeriesAddress?: PublicKeyish | null;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildDepositIntoCapitalClassTx(params: {
    owner: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    capitalClassAddress: PublicKeyish;
    assetMint: PublicKeyish;
    sourceTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    shares: bigint;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildRequestRedemptionTx(params: {
    owner: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    capitalClassAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    shares: bigint;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildProcessRedemptionQueueTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    capitalClassAddress: PublicKeyish;
    lpOwnerAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recipientTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    shares: bigint;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildWithdrawProtocolFeeSplTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recipientTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildWithdrawPoolTreasurySplTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recipientTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildWithdrawPoolOracleFeeSplTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    oracleAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recipientTokenAccountAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    vaultTokenAccountAddress?: PublicKeyish | null;
    tokenProgramId?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildWithdrawProtocolFeeSolTx(params: {
    authority: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    recipient: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    assetMint?: PublicKeyish;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildWithdrawPoolTreasurySolTx(params: {
    authority: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    recipient: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    assetMint?: PublicKeyish;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildWithdrawPoolOracleFeeSolTx(params: {
    authority: PublicKeyish;
    liquidityPoolAddress: PublicKeyish;
    oracleAddress: PublicKeyish;
    recipient: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    assetMint?: PublicKeyish;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildOpenMemberPositionTx(params: {
    wallet: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    recentBlockhash: string;
    seriesScopeAddress?: PublicKeyish | null;
    subjectCommitmentHashHex?: string | null;
    eligibilityStatus: number;
    delegatedRightsMask: number;
    proofMode: number;
    tokenGateAmountSnapshot: bigint;
    inviteIdHashHex?: string | null;
    inviteExpiresAt: bigint;
    anchorRefAddress?: PublicKeyish | null;
    tokenGateAccountAddress?: PublicKeyish | null;
    inviteAuthorityAddress?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildCreateObligationTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    obligationId: string;
    policySeriesAddress?: PublicKeyish | null;
    memberWalletAddress?: PublicKeyish | null;
    beneficiaryAddress?: PublicKeyish | null;
    claimCaseAddress?: PublicKeyish | null;
    liquidityPoolAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    deliveryMode: number;
    amount: bigint;
    creationReasonHashHex?: string | null;
    poolAssetMint?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildOpenClaimCaseTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    memberPositionAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    recentBlockhash: string;
    claimId: string;
    policySeriesAddress?: PublicKeyish | null;
    claimantAddress?: PublicKeyish | null;
    memberWalletAddress?: PublicKeyish | null;
    evidenceRefHashHex?: string | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildAttachClaimEvidenceRefTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    claimCaseAddress: PublicKeyish;
    recentBlockhash: string;
    evidenceRefHashHex?: string | null;
    decisionSupportHashHex?: string | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildAdjudicateClaimCaseTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    claimCaseAddress: PublicKeyish;
    recentBlockhash: string;
    reviewState: number;
    approvedAmount: bigint;
    deniedAmount: bigint;
    reserveAmount: bigint;
    decisionSupportHashHex?: string | null;
    obligationAddress?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildSettleClaimCaseTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    claimCaseAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    policySeriesAddress?: PublicKeyish | null;
    obligationAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    poolAssetMint?: PublicKeyish | null;
    protocolFeeVaultAddress?: PublicKeyish | null;
    programId?: PublicKeyish;
} & SettlementOutflowAccounts): Transaction;
export declare function buildSettleClaimCaseSelectedAssetTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    claimCaseAddress: PublicKeyish;
    memberPositionAddress: PublicKeyish;
    claimAssetMint: PublicKeyish;
    payoutAssetMint: PublicKeyish;
    payoutFundingLineAddress: PublicKeyish;
    payoutVaultTokenAccountAddress: PublicKeyish;
    recipientTokenAccountAddress: PublicKeyish;
    tokenProgramId: PublicKeyish;
    recentBlockhash: string;
    claimCreditAmount: bigint;
    payoutAmount: bigint;
    maxOverpayBps: number;
    settlementReasonHashHex?: string | null;
    policySeriesAddress?: PublicKeyish | null;
    claimAssetRailAddress?: PublicKeyish | null;
    payoutAssetRailAddress?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildReserveObligationTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    obligationAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    claimCaseAddress?: PublicKeyish | null;
    policySeriesAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    poolAssetMint?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildReleaseReserveTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    obligationAddress: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    claimCaseAddress?: PublicKeyish | null;
    policySeriesAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    poolAssetMint?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildSettleObligationTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    obligationAddress: PublicKeyish;
    recentBlockhash: string;
    nextStatus: number;
    amount: bigint;
    settlementReasonHashHex?: string | null;
    claimCaseAddress?: PublicKeyish | null;
    policySeriesAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    poolAssetMint?: PublicKeyish | null;
    reserveAssetRailAddress?: PublicKeyish | null;
    programId?: PublicKeyish;
} & SettlementOutflowAccounts): Transaction;
export declare function buildUpdateLpPositionCredentialingTx(params: {
    authority: PublicKeyish;
    poolAddress: PublicKeyish;
    capitalClassAddress: PublicKeyish;
    ownerAddress: PublicKeyish;
    recentBlockhash: string;
    credentialed: boolean;
    reasonHashHex?: string | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildMarkImpairmentTx(params: {
    authority: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    reserveDomainAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    assetMint: PublicKeyish;
    recentBlockhash: string;
    amount: bigint;
    reasonHashHex?: string | null;
    policySeriesAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    obligationAddress?: PublicKeyish | null;
    poolAssetMint?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildRegisterOracleTx(params: {
    admin: PublicKeyish;
    oracle: PublicKeyish;
    recentBlockhash: string;
    oracleType: number;
    displayName: string;
    legalName: string;
    websiteUrl: string;
    appUrl: string;
    logoUri: string;
    webhookUrl: string;
    supportedSchemaKeyHashesHex: string[];
    programId?: PublicKeyish;
}): Transaction;
export declare function buildClaimOracleTx(params: {
    oracle: PublicKeyish;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildUpdateOracleProfileTx(params: {
    authority: PublicKeyish;
    oracle: PublicKeyish;
    recentBlockhash: string;
    oracleType: number;
    displayName: string;
    legalName: string;
    websiteUrl: string;
    appUrl: string;
    logoUri: string;
    webhookUrl: string;
    supportedSchemaKeyHashesHex: string[];
    programId?: PublicKeyish;
}): Transaction;
export declare function buildSetPoolOracleTx(params: {
    authority: PublicKeyish;
    poolAddress: PublicKeyish;
    oracle: PublicKeyish;
    recentBlockhash: string;
    active: boolean;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildSetPoolOraclePermissionsTx(params: {
    authority: PublicKeyish;
    poolAddress: PublicKeyish;
    oracle: PublicKeyish;
    permissions: number;
    recentBlockhash: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildSetPoolOraclePolicyTx(params: {
    authority: PublicKeyish;
    poolAddress: PublicKeyish;
    recentBlockhash: string;
    quorumM: number;
    quorumN: number;
    requireVerifiedSchema: boolean;
    oracleFeeBps: number;
    allowDelegateClaim: boolean;
    challengeWindowSecs: number;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildRegisterOutcomeSchemaTx(params: {
    publisher: PublicKeyish;
    recentBlockhash: string;
    schemaKeyHashHex: string;
    schemaKey: string;
    version: number;
    schemaHashHex: string;
    schemaFamily: number;
    visibility: number;
    metadataUri: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildVerifyOutcomeSchemaTx(params: {
    governanceAuthority: PublicKeyish;
    recentBlockhash: string;
    schemaKeyHashHex: string;
    verified: boolean;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildBackfillSchemaDependencyLedgerTx(params: {
    governanceAuthority: PublicKeyish;
    recentBlockhash: string;
    schemaKeyHashHex: string;
    poolRuleAddresses: PublicKeyish[];
    programId?: PublicKeyish;
}): Transaction;
export declare function buildCloseOutcomeSchemaTx(params: {
    governanceAuthority: PublicKeyish;
    recipientSystemAccount: PublicKeyish;
    recentBlockhash: string;
    schemaKeyHashHex: string;
    programId?: PublicKeyish;
}): Transaction;
export declare function buildAttestClaimCaseTx(params: {
    oracle: PublicKeyish;
    healthPlanAddress: PublicKeyish;
    claimCaseAddress: PublicKeyish;
    fundingLineAddress: PublicKeyish;
    recentBlockhash: string;
    decision: number;
    attestationHashHex: string;
    attestationRefHashHex?: string | null;
    schemaKeyHashHex: string;
    liquidityPoolAddress?: PublicKeyish | null;
    capitalClassAddress?: PublicKeyish | null;
    allocationPositionAddress?: PublicKeyish | null;
    poolOracleApprovalAddress?: PublicKeyish | null;
    poolOraclePermissionSetAddress?: PublicKeyish | null;
    poolOraclePolicyAddress?: PublicKeyish | null;
    programId?: PublicKeyish;
}): Transaction;
export declare function compileTransactionToV0(transaction: Transaction, lookupTableAccounts: AddressLookupTableAccount[]): VersionedTransaction;
export declare function preflightClassicTokenAccount(params: {
    connection: Connection;
    tokenAccountAddress: PublicKeyish;
    mintAddress: PublicKeyish;
    ownerAddress?: PublicKeyish | null;
    label?: string;
}): Promise<void>;
export interface SafeProtocolClientOptions {
    programId?: PublicKeyish;
    unsafeAllowCustomProgramId?: boolean;
}
export type SafeFundSponsorBudgetTxParams = Omit<Parameters<typeof buildFundSponsorBudgetTx>[0], 'programId'>;
export type SafeRecordPremiumPaymentTxParams = Omit<Parameters<typeof buildRecordPremiumPaymentTx>[0], 'programId'>;
export type SafeDepositIntoCapitalClassTxParams = Omit<Parameters<typeof buildDepositIntoCapitalClassTx>[0], 'programId'>;
export type SafeRequestRedemptionTxParams = Omit<Parameters<typeof buildRequestRedemptionTx>[0], 'programId'>;
export type SafeProcessRedemptionQueueTxParams = Omit<Parameters<typeof buildProcessRedemptionQueueTx>[0], 'programId'>;
export type SafeWithdrawProtocolFeeSplTxParams = Omit<Parameters<typeof buildWithdrawProtocolFeeSplTx>[0], 'programId'>;
export type SafeWithdrawPoolTreasurySplTxParams = Omit<Parameters<typeof buildWithdrawPoolTreasurySplTx>[0], 'programId'>;
export type SafeWithdrawPoolOracleFeeSplTxParams = Omit<Parameters<typeof buildWithdrawPoolOracleFeeSplTx>[0], 'programId'>;
export type SafeWithdrawProtocolFeeSolTxParams = Omit<Parameters<typeof buildWithdrawProtocolFeeSolTx>[0], 'programId'>;
export type SafeWithdrawPoolTreasurySolTxParams = Omit<Parameters<typeof buildWithdrawPoolTreasurySolTx>[0], 'programId'>;
export type SafeWithdrawPoolOracleFeeSolTxParams = Omit<Parameters<typeof buildWithdrawPoolOracleFeeSolTx>[0], 'programId'>;
export type SafeOpenClaimCaseTxParams = Omit<Parameters<typeof buildOpenClaimCaseTx>[0], 'programId'>;
export type SafeReserveObligationTxParams = Omit<Parameters<typeof buildReserveObligationTx>[0], 'programId'>;
export type SafeReleaseReserveTxParams = Omit<Parameters<typeof buildReleaseReserveTx>[0], 'programId'>;
export type SafeSettleObligationTxParams = Omit<Parameters<typeof buildSettleObligationTx>[0], 'programId'> & {
    recipientOwnerAddress: PublicKeyish;
};
export type SafeSettleClaimCaseTxParams = Omit<Parameters<typeof buildSettleClaimCaseTx>[0], 'programId'> & {
    recipientOwnerAddress: PublicKeyish;
};
export type SafeSettleClaimCaseSelectedAssetTxParams = Omit<Parameters<typeof buildSettleClaimCaseSelectedAssetTx>[0], 'programId'> & {
    recipientOwnerAddress: PublicKeyish;
};
export type SafeMarkImpairmentTxParams = Omit<Parameters<typeof buildMarkImpairmentTx>[0], 'programId'>;
export type SafeRegisterOracleTxParams = Omit<Parameters<typeof buildRegisterOracleTx>[0], 'programId'>;
export type SafeAttestClaimCaseTxParams = Omit<Parameters<typeof buildAttestClaimCaseTx>[0], 'programId'>;
export interface SafeProtocolClient {
    connection: Connection;
    programId: PublicKey;
    raw: ProtocolClient;
    getProgramId(): PublicKey;
    buildFundSponsorBudgetTx(params: SafeFundSponsorBudgetTxParams): Promise<Transaction>;
    buildRecordPremiumPaymentTx(params: SafeRecordPremiumPaymentTxParams): Promise<Transaction>;
    buildDepositIntoCapitalClassTx(params: SafeDepositIntoCapitalClassTxParams): Promise<Transaction>;
    buildRequestRedemptionTx(params: SafeRequestRedemptionTxParams): Transaction;
    buildProcessRedemptionQueueTx(params: SafeProcessRedemptionQueueTxParams): Promise<Transaction>;
    buildWithdrawProtocolFeeSplTx(params: SafeWithdrawProtocolFeeSplTxParams): Promise<Transaction>;
    buildWithdrawPoolTreasurySplTx(params: SafeWithdrawPoolTreasurySplTxParams): Promise<Transaction>;
    buildWithdrawPoolOracleFeeSplTx(params: SafeWithdrawPoolOracleFeeSplTxParams): Promise<Transaction>;
    buildWithdrawProtocolFeeSolTx(params: SafeWithdrawProtocolFeeSolTxParams): Transaction;
    buildWithdrawPoolTreasurySolTx(params: SafeWithdrawPoolTreasurySolTxParams): Transaction;
    buildWithdrawPoolOracleFeeSolTx(params: SafeWithdrawPoolOracleFeeSolTxParams): Transaction;
    buildOpenClaimCaseTx(params: SafeOpenClaimCaseTxParams): Transaction;
    buildReserveObligationTx(params: SafeReserveObligationTxParams): Transaction;
    buildReleaseReserveTx(params: SafeReleaseReserveTxParams): Transaction;
    buildSettleObligationTx(params: SafeSettleObligationTxParams): Promise<Transaction>;
    buildSettleClaimCaseTx(params: SafeSettleClaimCaseTxParams): Promise<Transaction>;
    buildSettleClaimCaseSelectedAssetTx(params: SafeSettleClaimCaseSelectedAssetTxParams): Promise<Transaction>;
    buildMarkImpairmentTx(params: SafeMarkImpairmentTxParams): Transaction;
    buildRegisterOracleTx(params: SafeRegisterOracleTxParams): Transaction;
    buildAttestClaimCaseTx(params: SafeAttestClaimCaseTxParams): Transaction;
}
export declare function createSafeProtocolClient(connection: Connection, options?: SafeProtocolClientOptions): SafeProtocolClient;
export declare function createProtocolClient(connection: Connection, programId?: PublicKeyish, options?: {
    unsafeAllowCustomProgramId?: boolean;
}): ProtocolClient;
export { PROTOCOL_ACCOUNT_DISCRIMINATORS, PROTOCOL_INSTRUCTION_ACCOUNTS, PROTOCOL_INSTRUCTION_DISCRIMINATORS, PROTOCOL_PROGRAM_ID, getProgramId, };