import type { Hex } from 'viem';
import type { GraphQLExecutionErrors, MintSchedule } from './types';
import type { ZodError } from 'zod';
export declare class MissingSignerError extends Error {
    readonly name = "MissingSignerError";
    constructor();
}
export declare class MissingProviderError extends Error {
    readonly name = "MissingProviderError";
    constructor();
}
export declare class UnsupportedMinterError extends Error {
    readonly name = "UnsupportedMinterError";
    readonly interfaceId: string;
    constructor({ interfaceId }: {
        interfaceId: string;
    });
}
export declare class SamNotFoundError extends Error {
    readonly name = "SamNotFoundError";
    readonly contractAddress: string;
    constructor({ contractAddress }: {
        contractAddress: string;
    });
}
export declare class SoundNotFoundError extends Error {
    readonly name = "SoundNotFoundError";
    readonly contractAddress: string;
    readonly editionId: string | null;
    readonly graphqlErrors: GraphQLExecutionErrors | undefined;
    constructor({ contractAddress, editionId, graphqlErrors, }: {
        contractAddress: string;
        editionId?: string | null;
        graphqlErrors: GraphQLExecutionErrors | undefined;
    });
}
export declare class SoundAPIGraphQLError extends Error {
    readonly name = "SoundAPIGraphQLError";
    readonly graphqlErrors: GraphQLExecutionErrors;
    constructor({ graphqlErrors }: {
        graphqlErrors: GraphQLExecutionErrors;
    });
}
export declare class UnexpectedApiResponse extends Error {
    readonly name = "UnexpectedApiResponseError";
    readonly originalError?: Error;
    readonly unexpectedOriginalError?: unknown;
    readonly graphqlErrors?: GraphQLExecutionErrors;
    constructor({ message, error, graphqlErrors, }?: {
        message?: string;
        error?: unknown;
        graphqlErrors?: GraphQLExecutionErrors;
    });
}
export declare class InvalidQuantityError extends Error {
    readonly name = "InvalidQuantityError";
    readonly quantity: number;
    constructor({ quantity }: {
        quantity: number;
    });
}
export declare class InvalidOffsetError extends Error {
    readonly name = "InvalidOffsetError";
    readonly offset: number;
    constructor({ offset }: {
        offset: number;
    });
}
export declare class NotEligibleMint extends Error {
    readonly name = "NotEligibleMintError";
    readonly userAddress: string;
    readonly eligibleMintQuantity?: bigint;
    readonly mintSchedule: MintSchedule;
    constructor({ userAddress, eligibleMintQuantity, mintSchedule, }: {
        userAddress: string;
        eligibleMintQuantity?: bigint;
        mintSchedule: MintSchedule;
    });
}
export declare class MissingApiKey extends Error {
    readonly name = "MissingApiKeyError";
    constructor();
}
export declare class MissingSoundAPI extends Error {
    readonly name = "MissingSoundAPIError";
    constructor();
}
export declare class MissingMerkleProvider extends Error {
    readonly name = "MissingMerkleProviderError";
    constructor();
}
export declare class UnexpectedLanyardResponse extends Error {
    readonly name = "UnexpectedLanyardResponseError";
    readonly response: Response | null;
    readonly zodError: ZodError | null;
    constructor({ response, zodError, cause }: {
        response: Response | null;
        zodError?: ZodError;
        cause?: unknown;
    });
}
export declare class InvalidEditionMaxMintableError extends Error {
    readonly name = "InvalidEditionMaxMintableError";
    readonly editionMaxMintableLower: number;
    readonly editionMaxMintableUpper: number;
    constructor({ editionMaxMintableLower, editionMaxMintableUpper, }: {
        editionMaxMintableLower: number;
        editionMaxMintableUpper: number;
    });
}
export declare class InvalidMaxMintableError extends Error {
    readonly name = "InvalidMaxMintableError";
    readonly maxMintableLower: number;
    readonly maxMintableUpper: number;
    constructor({ maxMintableLower, maxMintableUpper }: {
        maxMintableLower: number;
        maxMintableUpper: number;
    });
}
export declare class InvalidMaxMintablePerAccountError extends Error {
    readonly name = "InvalidMaxMintablePerAccountError";
    readonly maxMintablePerAccount: number;
    constructor({ maxMintablePerAccount }: {
        maxMintablePerAccount: number;
    });
}
export declare class InvalidMerkleRootError extends Error {
    readonly name = "InvalidMerkleRootError";
    readonly merkleRoot: Hex;
    constructor({ merkleRoot }: {
        merkleRoot: Hex;
    });
}
export declare class InvalidTimeValuesError extends Error {
    readonly name = "InvalidTimeValuesError";
    readonly startTime: number;
    readonly cutoffTime: number;
    readonly endTime: number;
    constructor({ startTime, cutoffTime, endTime }: {
        startTime: number;
        cutoffTime: number;
        endTime: number;
    });
}