import { d as NFTMetadata, L as LazyMintVoucher, T as TxResult, f as ListingParams, e as NFT, g as TipData, h as TipResult, i as TipStats, j as SubscriptionPlan, k as Subscription, E as EarningsBreakdown, R as RevenueSplit } from '../index-BLuxEdLp.js';

/**
 * ZubariNFTProtocol - NFT creation and marketplace operations
 *
 * Handles lazy minting via EIP-712 signatures, NFT listing,
 * and marketplace operations on Ethereum network.
 */
declare class ZubariNFTProtocol {
    private readonly contractAddress;
    private readonly _marketplaceAddress;
    private readonly chainId;
    constructor(contractAddress: string, marketplaceAddress: string, chainId: number);
    /**
     * Create a lazy mint voucher for off-chain NFT creation
     * The voucher can be redeemed on-chain when purchased
     */
    createLazyMintVoucher(metadata: NFTMetadata, creatorAddress: string, signer: {
        signTypedData: (domain: object, types: object, value: object) => Promise<string>;
    }): Promise<LazyMintVoucher>;
    /**
     * Redeem a lazy mint voucher to mint the NFT on-chain
     */
    redeemVoucher(voucher: LazyMintVoucher, _buyerAddress: string): Promise<TxResult>;
    /**
     * List an NFT for sale on the marketplace
     */
    listForSale(_params: ListingParams): Promise<TxResult>;
    /**
     * Buy an NFT from the marketplace
     */
    buyNFT(_listingId: string, _price: bigint): Promise<TxResult>;
    /**
     * Transfer an NFT to another address
     */
    transfer(_tokenId: string, _to: string): Promise<TxResult>;
    /**
     * Get NFTs owned by an address
     */
    getOwnedNFTs(_address: string): Promise<NFT[]>;
    /**
     * Generate a random tokenId (32 bytes hex)
     */
    private generateTokenId;
}

/**
 * ZubariTipsProtocol - Micropayment tips for creators
 *
 * Handles ETH and ERC-20 token tips with platform fee distribution.
 * Supports gasless tips via ERC-4337 when enabled.
 */
declare class ZubariTipsProtocol {
    private readonly contractAddress;
    private readonly chainId;
    private readonly gaslessEnabled;
    constructor(contractAddress: string, chainId: number, gaslessEnabled?: boolean);
    /**
     * Send a tip to a creator
     */
    sendTip(tip: TipData): Promise<TipResult>;
    /**
     * Send tips to multiple creators in a single transaction
     */
    sendBatchTips(tips: TipData[]): Promise<TipResult[]>;
    /**
     * Get tips received by an address
     */
    getTipsReceived(address: string): Promise<TipResult[]>;
    /**
     * Get tips sent by an address
     */
    getTipsSent(address: string): Promise<TipResult[]>;
    /**
     * Get tip statistics for a creator
     */
    getCreatorTipStats(creator: string): Promise<TipStats>;
    /**
     * Get platform fee in basis points
     */
    getPlatformFeeBps(): number;
}

/**
 * ZubariSubscriptionProtocol - Recurring subscription payments
 *
 * Handles subscription plan creation, subscription management,
 * and verification of active subscriptions.
 */
declare class ZubariSubscriptionProtocol {
    private readonly contractAddress;
    private readonly chainId;
    constructor(contractAddress: string, chainId: number);
    /**
     * Create a new subscription plan
     */
    createPlan(plan: SubscriptionPlan): Promise<string>;
    /**
     * Update an existing subscription plan
     */
    updatePlan(planId: string, updates: Partial<SubscriptionPlan>): Promise<TxResult>;
    /**
     * Subscribe to a creator's plan
     */
    subscribe(creator: string, planId: string, months?: number): Promise<Subscription>;
    /**
     * Cancel an active subscription
     */
    cancel(subscriptionId: string): Promise<TxResult>;
    /**
     * Check if an address is subscribed to a creator
     */
    isSubscribed(creator: string, subscriber?: string): Promise<boolean>;
    /**
     * Get active subscriptions for a subscriber
     */
    getActiveSubscriptions(subscriber?: string): Promise<Subscription[]>;
    /**
     * Get all subscribers for a creator
     */
    getSubscribers(creator: string): Promise<Subscription[]>;
    /**
     * Get a specific plan by ID
     */
    getPlan(planId: string): Promise<SubscriptionPlan | null>;
    /**
     * Get all plans for a creator
     */
    getCreatorPlans(creator: string): Promise<SubscriptionPlan[]>;
    /**
     * Generate a unique plan ID
     */
    private generatePlanId;
}

/**
 * ZubariPayoutsProtocol - Creator earnings management
 *
 * Handles earnings tracking, claiming, revenue splits,
 * and conversion to stablecoins.
 */
declare class ZubariPayoutsProtocol {
    private readonly contractAddress;
    private readonly chainId;
    constructor(contractAddress: string, chainId: number);
    /**
     * Get pending earnings breakdown for the current user
     */
    getPendingEarnings(): Promise<EarningsBreakdown>;
    /**
     * Get historical earnings for a time period
     */
    getEarningsHistory(period?: 'day' | 'week' | 'month' | 'all'): Promise<EarningsBreakdown[]>;
    /**
     * Claim all pending earnings
     */
    claimEarnings(): Promise<TxResult>;
    /**
     * Claim specific amount of earnings
     */
    claimPartialEarnings(amount: bigint): Promise<TxResult>;
    /**
     * Setup revenue split with collaborators
     * Basis points must sum to 10000 (100%)
     */
    setupRevenueSplit(splits: RevenueSplit[]): Promise<TxResult>;
    /**
     * Get current revenue split configuration
     */
    getRevenueSplit(): Promise<RevenueSplit[]>;
    /**
     * Remove revenue split (creator gets 100%)
     */
    removeRevenueSplit(): Promise<TxResult>;
    /**
     * Convert earnings to stablecoin (USDT)
     */
    convertToStable(token: string, amount: bigint): Promise<TxResult>;
}

export { ZubariNFTProtocol, ZubariPayoutsProtocol, ZubariSubscriptionProtocol, ZubariTipsProtocol };