import { Address, Rpc, GetAccountInfoApi, GetProgramAccountsApi, GetMultipleAccountsApi } from '@solana/kit';
import { Schema } from 'borsh';

/** Tags identifying the SNS NFT state variant. */
declare enum NftTag {
    Uninitialized = 0,
    CentralState = 1,
    ActiveRecord = 2,
    InactiveRecord = 3
}
/**
 * Input for decoding an SNS NFT account.
 *
 * @example
 * ```ts
 * const params: NftStateParams = { tag: 2, nonce: 0, nameAccount, owner, nftMint };
 * ```
 */
interface NftStateParams {
    /** NFT state tag. */
    tag: number;
    /** NFT record nonce. */
    nonce: number;
    /** Encoded SNS domain account address. */
    nameAccount: Uint8Array;
    /** Encoded NFT owner address. */
    owner: Uint8Array;
    /** Encoded NFT mint address. */
    nftMint: Uint8Array;
}
/** Decoded state of an SNS NFT account. */
declare class NftState {
    /** NFT state tag. */
    tag: NftTag;
    /** NFT record nonce. */
    nonce: number;
    /** SNS domain account address. */
    nameAccount: Address;
    /** NFT owner address. */
    owner: Address;
    /** NFT mint address. */
    nftMint: Address;
    static schema: {
        struct: {
            tag: string;
            nonce: string;
            nameAccount: {
                array: {
                    type: string;
                    len: number;
                };
            };
            owner: {
                array: {
                    type: string;
                    len: number;
                };
            };
            nftMint: {
                array: {
                    type: string;
                    len: number;
                };
            };
        };
    };
    static LEN: number;
    constructor(obj: NftStateParams);
    static deserialize(data: Uint8Array): NftState;
    static retrieve(rpc: Rpc<GetAccountInfoApi>, address: Address): Promise<NftState>;
    static retrieveFromMint(rpc: Rpc<GetProgramAccountsApi>, mint: Address): Promise<NftState>;
    static getAddress(domainAddress: Address): Promise<Address>;
}

/**
 * Input for decoding an SNS primary-domain account.
 *
 * @example
 * ```ts
 * const params: PrimaryDomainStateParams = { tag: 0, nameAccount };
 * ```
 */
interface PrimaryDomainStateParams {
    /** Account state tag. */
    tag: number;
    /** Encoded primary domain account address. */
    nameAccount: Uint8Array;
}
/** Decoded state of an SNS primary-domain account. */
declare class PrimaryDomainState {
    /** Account state tag. */
    tag: number;
    /** Primary domain account address. */
    nameAccount: Address;
    static schema: {
        struct: {
            tag: string;
            nameAccount: {
                array: {
                    type: string;
                    len: number;
                };
            };
        };
    };
    constructor(obj: PrimaryDomainStateParams);
    static deserialize(data: Uint8Array): PrimaryDomainState;
    static retrieve(rpc: Rpc<GetAccountInfoApi>, address: Address): Promise<PrimaryDomainState>;
    static _retrieveBatch(rpc: Rpc<GetMultipleAccountsApi>, primaryAddresses: Address[]): Promise<(PrimaryDomainState | undefined)[]>;
    static retrieveBatch(rpc: Rpc<GetMultipleAccountsApi>, primaryAddresses: Address[]): Promise<(PrimaryDomainState | undefined)[]>;
    static getAddress(programAddress: Address, walletAddress: Address): Promise<Address<string>>;
}

/** Validation modes encoded in an SNS record header. */
declare enum Validation {
    None = 0,
    Solana = 1,
    Ethereum = 2,
    UnverifiedSolana = 3
}

/** Byte length of the common SNS name-registry account header. */
declare const NAME_REGISTRY_LEN = 96;
/**
 * Returns the byte length of an identifier encoded for a validation mode.
 *
 * @example
 * ```ts
 * const length = getValidationLength(Validation.Solana);
 * ```
 */
declare const getValidationLength: (validation: Validation) => 32 | 0 | 20;
/**
 * Input for decoding an SNS V2 record header.
 *
 * @example
 * ```ts
 * const params: RecordHeaderStateParams = { stalenessValidation: 0, rightOfAssociationValidation: 0, contentLength: 0 };
 * ```
 */
interface RecordHeaderStateParams {
    /** Staleness validation mode. */
    stalenessValidation: number;
    /** Right of Association validation mode. */
    rightOfAssociationValidation: number;
    /** Record content length in bytes. */
    contentLength: number;
}
/** Decoded header of an SNS V2 record account. */
declare class RecordHeaderState {
    /** Staleness validation mode. */
    stalenessValidation: number;
    /** Right of Association validation mode. */
    rightOfAssociationValidation: number;
    /** Record content length in bytes. */
    contentLength: number;
    static schema: Schema;
    static LEN: number;
    constructor(obj: RecordHeaderStateParams);
    static deserialize(data: Uint8Array): RecordHeaderState;
    static retrieve(rpc: Rpc<GetAccountInfoApi>, address: Address): Promise<RecordHeaderState>;
}
/** Decoded SNS V2 record account, including its validation data and content. */
declare class RecordState {
    /** Decoded record header. */
    header: RecordHeaderState;
    /** Validation identifiers and record content. */
    data: Uint8Array;
    constructor(header: RecordHeaderState, data: Uint8Array);
    static deserialize(data: Uint8Array): RecordState;
    static retrieve(rpc: Rpc<GetAccountInfoApi>, address: Address): Promise<RecordState>;
    static retrieveBatch(rpc: Rpc<GetMultipleAccountsApi>, addresses: Address[]): Promise<(RecordState | undefined)[]>;
    getContent(): Uint8Array;
    getStalenessId(): Uint8Array;
    getRoAId(): Uint8Array;
}

/**
 * Input for decoding an SNS name-registry account.
 *
 * @example
 * ```ts
 * const params: RegistryStateParams = { parentName, owner, class: classAddress };
 * ```
 */
interface RegistryStateParams {
    /** Encoded parent registry address. */
    parentName: Uint8Array;
    /** Encoded registry owner address. */
    owner: Uint8Array;
    /** Encoded registry class address. */
    class: Uint8Array;
}
/** Decoded state of an SNS name-registry account. */
declare class RegistryState {
    /** Parent registry address. */
    parentName: Address;
    /** Registry owner address. */
    owner: Address;
    /** Registry class address. */
    class: Address;
    /** Registry data after the fixed header. */
    data: Uint8Array | undefined;
    static schema: {
        struct: {
            parentName: {
                array: {
                    type: string;
                    len: number;
                };
            };
            owner: {
                array: {
                    type: string;
                    len: number;
                };
            };
            class: {
                array: {
                    type: string;
                    len: number;
                };
            };
        };
    };
    static HEADER_LEN: number;
    constructor(obj: RegistryStateParams);
    static deserialize(data: Uint8Array): RegistryState;
    static retrieve(rpc: Rpc<GetAccountInfoApi>, address: Address): Promise<RegistryState>;
    static _retrieveBatch(rpc: Rpc<GetMultipleAccountsApi>, domainAddresses: Address[]): Promise<(RegistryState | undefined)[]>;
    static retrieveBatch(rpc: Rpc<GetMultipleAccountsApi>, domainAddresses: Address[]): Promise<(RegistryState | undefined)[]>;
}

export { NAME_REGISTRY_LEN, NftState, NftTag, PrimaryDomainState, RecordHeaderState, RecordState, RegistryState, getValidationLength };
export type { NftStateParams, PrimaryDomainStateParams, RecordHeaderStateParams, RegistryStateParams };