import { Address, ReadonlyUint8Array, Rpc, GetAccountInfoApi, GetMultipleAccountsApi } from '@solana/kit';
import * as _solana_addresses from '@solana/addresses';

/**
 * Returns whether a Solana address represents a valid Ed25519 curve point.
 *
 * @param address Solana address to validate
 * @returns Whether the address is an Ed25519 curve point
 *
 * @example
 * ```ts
 * const onCurve = checkAddressOnCurve(address);
 * ```
 */
declare function checkAddressOnCurve(address: Address): boolean;

/**
 * Supported SNS record identifiers.
 */
declare enum Record {
    IPFS = "IPFS",
    ARWV = "ARWV",
    SOL = "SOL",
    ETH = "ETH",
    BTC = "BTC",
    LTC = "LTC",
    DOGE = "DOGE",
    Email = "email",
    Url = "url",
    Discord = "discord",
    Github = "github",
    Reddit = "reddit",
    Twitter = "twitter",
    Telegram = "telegram",
    Pic = "pic",
    SHDW = "SHDW",
    POINT = "POINT",
    BSC = "BSC",
    Injective = "INJ",
    Backpack = "backpack",
    A = "A",
    AAAA = "AAAA",
    CNAME = "CNAME",
    TXT = "TXT",
    Background = "background",
    BASE = "BASE",
    IPNS = "IPNS",
    Bio = "bio"
}

/**
 * Parameters for deserializing record content.
 *
 * @example
 * ```ts
 * const params: DeserializeRecordContentParams = { content, record: Record.Url };
 * ```
 */
interface DeserializeRecordContentParams {
    /** Serialized record content. */
    content: ReadonlyUint8Array;
    /** Record type. */
    record: Record;
}
/**
 * Deserializes record content according to SNS-IP 1.
 *
 * `CNAME` and `TXT` content is punycode-decoded after UTF-8 deserialization.
 *
 * @param params Record deserialization parameters
 * @param params.content Serialized record content
 * @param params.record Record type
 * @returns Deserialized record content.
 * @throws InvalidRecordDataError If the record type or content is unsupported.
 *
 * @example
 * ```ts
 * const result = await getDomainRecord({
 *   rpc,
 *   domain: "example.sns",
 *   record: Record.Url,
 * });
 * const content = deserializeRecordContent({
 *   content: result.retrievedRecord.getContent(),
 *   record: Record.Url,
 * });
 * ```
 */
declare const deserializeRecordContent: ({ content, record, }: DeserializeRecordContentParams) => string;

/**
 * Parameters for deserializing reverse account data.
 *
 * @example
 * ```ts
 * const params: DeserializeReverseParams = { data: reverseAccountData };
 * ```
 */
interface DeserializeReverseParams {
    /** Reverse account data. */
    data: ReadonlyUint8Array | undefined;
    /** Whether to remove a subdomain's leading null byte. Defaults to false. */
    trimFirstNullByte?: boolean;
}
/**
 * Deserializes reverse account data.
 *
 * The first four bytes encode the reverse name length.
 *
 * @param params Reverse deserialization parameters
 * @param params.data Reverse account data. If undefined, returns undefined
 * @param params.trimFirstNullByte Whether to trim the first null byte for subdomain reverse names. Defaults to false
 * @returns The deserialized string, or `undefined` if data is undefined.
 *
 * @example
 * ```ts
 * const name = deserializeReverse({ data: reverseAccountData });
 * ```
 */
declare function deserializeReverse({ data, trimFirstNullByte, }: DeserializeReverseParams): string;
declare function deserializeReverse({ data, trimFirstNullByte, }: DeserializeReverseParams): undefined;

/**
 * Parameters for deriving a Pyth feed address.
 *
 * @example
 * ```ts
 * const params: GetPythFeedAddressParams = { shard: 0, priceFeed };
 * ```
 */
interface GetPythFeedAddressParams {
    /** Pyth feed shard number. */
    shard: number;
    /** Pyth price feed ID bytes. */
    priceFeed: number[];
}
/**
 * Derives the Pyth feed PDA for a shard and price feed.
 *
 * @param params Pyth feed derivation parameters
 * @param params.shard Shard number associated with the Pyth feed
 * @param params.priceFeed Feed ID bytes
 * @returns The Pyth feed address.
 *
 * @example
 * ```ts
 * const address = await getPythFeedAddress({ shard: 0, priceFeed });
 * ```
 */
declare const getPythFeedAddress: ({ shard, priceFeed, }: GetPythFeedAddressParams) => Promise<_solana_addresses.Address<string>>;

/**
 * Derives the reverse lookup account address for a TLD-trimmed SNS domain.
 *
 * @param domain TLD-trimmed SNS domain name
 * @returns The reverse lookup account address.
 *
 * @example
 * ```ts
 * const address = await getReverseAddress("example");
 * ```
 */
declare const getReverseAddress: (domain: string) => Promise<_solana_addresses.Address>;

/**
 * Parameters for deriving a reverse lookup address.
 *
 * @example
 * ```ts
 * const params: GetReverseAddressFromDomainAddressParams = { domainAddress };
 * ```
 */
interface GetReverseAddressFromDomainAddressParams {
    /** Domain account address. */
    domainAddress: Address;
    /** Parent domain address for a subdomain. */
    parentAddress?: Address;
}
/**
 * Derives the reverse lookup account address from a domain address.
 *
 * @param params Reverse lookup derivation parameters
 * @param params.domainAddress Domain account address to reverse look up
 * @param params.parentAddress Optional parent address for subdomain reverse lookups
 * @returns The reverse lookup account address.
 *
 * @example
 * ```ts
 * const address = await getReverseAddressFromDomainAddress({ domainAddress });
 * ```
 */
declare const getReverseAddressFromDomainAddress: ({ domainAddress, parentAddress, }: GetReverseAddressFromDomainAddressParams) => Promise<Address>;

/**
 * Parameters for reverse lookup.
 *
 * @example
 * ```ts
 * const params: ReverseLookupParams = { rpc, domainAddress };
 * ```
 */
interface ReverseLookupParams {
    /** RPC client. */
    rpc: Rpc<GetAccountInfoApi>;
    /** Domain account address. */
    domainAddress: Address;
    /** Parent domain address for a subdomain. */
    parentAddress?: Address;
}
/**
 * Performs a reverse lookup for a domain address.
 *
 * @param params Reverse lookup parameters
 * @param params.rpc RPC client implementing account lookup
 * @param params.domainAddress Domain address to reverse look up
 * @param params.parentAddress Optional parent domain address for subdomain reverse lookups
 * @returns Human-readable domain name.
 * @throws NoAccountDataError If the registry data is empty.
 *
 * @example
 * ```ts
 * const name = await reverseLookup({ rpc, domainAddress });
 * ```
 */
declare function reverseLookup({ rpc, domainAddress, parentAddress, }: ReverseLookupParams): Promise<string>;

/**
 * Parameters for batch reverse lookup.
 *
 * @example
 * ```ts
 * const params: ReverseLookupBatchParams = { rpc, domainAddresses };
 * ```
 */
interface ReverseLookupBatchParams {
    /** RPC client. */
    rpc: Rpc<GetMultipleAccountsApi>;
    /** Domain account addresses. */
    domainAddresses: Address[];
}
/**
 * Performs reverse lookups for domain addresses.
 *
 * @param params Reverse lookup parameters
 * @param params.rpc RPC client implementing multiple-account lookup
 * @param params.domainAddresses Domain addresses to reverse look up
 * @returns Human-readable domain names, or `undefined` when reverse account data is unavailable.
 *
 * @example
 * ```ts
 * const domains = await reverseLookupBatch({ rpc, domainAddresses });
 * ```
 */
declare function reverseLookupBatch({ rpc, domainAddresses, }: ReverseLookupBatchParams): Promise<(string | undefined)[]>;

/**
 * Parameters for serializing record content.
 *
 * @example
 * ```ts
 * const params: SerializeRecordContentParams = {
 *   content: "https://example.com",
 *   record: Record.Url,
 * };
 * ```
 */
interface SerializeRecordContentParams {
    /** Record content. */
    content: string;
    /** Record type. */
    record: Record;
}
/**
 * Serializes record content according to SNS-IP 1.
 *
 * `CNAME` and `TXT` content is punycode-encoded before UTF-8 serialization.
 *
 * @param params Record serialization parameters
 * @param params.content Record content to serialize
 * @param params.record Record type
 * @returns Serialized record content.
 * @throws InvalidEvmAddressError, InvalidInjectiveAddressError, InvalidARecordError,
 * InvalidAAAARecordError, or InvalidRecordInputError when the record content is invalid or unsupported.
 *
 * @example
 * ```ts
 * const content = serializeRecordContent({
 *   content: "https://example.com",
 *   record: Record.Url,
 * });
 * ```
 */
declare const serializeRecordContent: ({ content, record, }: SerializeRecordContentParams) => ReadonlyUint8Array;

/** The Solana Name Service top-level domain. */
declare const SOL_TLD = ".sol";
/** The Bonfida SNS top-level domain. */
declare const SNS_TLD = ".sns";
/** A top-level domain supported by this SDK. */
type SupportedTld = typeof SNS_TLD | typeof SOL_TLD;
/** TLD suffixes accepted by the domain parsing and resolution helpers. */
declare const SUPPORTED_TLDS: readonly SupportedTld[];
/**
 * Returns the matching TLD from `supportedTlds` if `domain` ends with one,
 * or `undefined` otherwise.
 *
 * @param domain Domain name to inspect
 * @param supportedTlds Supported suffixes to match against
 * @returns The matching suffix, or `undefined` when none match.
 *
 * @example
 * ```ts
 * const tld = getTld("example.sns");
 * ```
 */
declare const getTld: (domain: string, supportedTlds?: readonly string[]) => string | undefined;
/**
 * Ensures `domain` ends with one of the `supportedTlds` and strips that suffix.
 *
 * @param domain Domain name to parse
 * @param supportedTlds Supported suffixes to match against
 * @returns Domain name without suffix and the matching suffix.
 * @throws UnsupportedTldError If no supported suffix matches.
 *
 * @example
 * ```ts
 * const [domain, tld] = parseSupportedTld("example.sns");
 * ```
 */
declare const parseSupportedTld: (domain: string, supportedTlds?: readonly string[]) => [string, string];
/**
 * Ensures `domain` ends with `.sns` and strips that suffix.
 *
 * @param domain Domain name to parse
 * @returns Domain name without suffix and the `.sns` suffix.
 * @throws UnsupportedTldError If the domain does not end with `.sns`.
 *
 * @example
 * ```ts
 * const [domain] = parseSnsTld("example.sns");
 * ```
 */
declare const parseSnsTld: (domain: string) => [string, string];

export { SNS_TLD, SOL_TLD, SUPPORTED_TLDS, checkAddressOnCurve, deserializeRecordContent, deserializeReverse, getPythFeedAddress, getReverseAddress, getReverseAddressFromDomainAddress, getTld, parseSnsTld, parseSupportedTld, reverseLookup, reverseLookupBatch, serializeRecordContent };
export type { DeserializeRecordContentParams, DeserializeReverseParams, GetPythFeedAddressParams, GetReverseAddressFromDomainAddressParams, ReverseLookupBatchParams, ReverseLookupParams, SerializeRecordContentParams, SupportedTld };