import { z } from 'zod';
import { I as Item, a as ItemCreateRequest, b as ItemUpdateRequest } from './item-DNCZNa4O.js';
export { c as ItemShipping, d as ItemVariation } from './item-DNCZNa4O.js';
export { A as AutoApprovePolicy, F as FetchLabelsInput, H as HitlConfig, a as HitlContext, b as HitlDecision, c as HitlOpKind, d as HitlRejectedError, L as LabelFormat, R as RequireConfirmation, S as Shipment, e as ShipmentHistoryEntry, f as ShipmentItem, g as ShipmentLogisticType, h as ShipmentMode, i as ShipmentReceiverAddress, j as ShipmentStatus, k as ShippingOption, l as ShippingOptionsResponse, m as classifyHitlSeverity, n as denyAllAutoApprove, o as fetchLabelsBlob, p as getShipment, q as getShipmentHistory, r as getShippingOptions } from './shipments-Bruwee4L.js';
import { ArAgentsError } from '@ar-agents/core';
import { M as MeliClient } from './client-CQBMd2Qk.js';
export { A as AuthMode, B as BuildAuthUrlInput, F as FetchOptions, I as InMemoryOAuthStore, a as MeliClientOptions, b as MeliOAuthTokens, N as NoopRateLimiter, O as OAuthAppCredentials, c as OAuthTokenStore, R as RateLimiter, d as RetryClassifier, e as RetryContext, f as RetryDecision, g as RetryOptions, T as TelemetryHooks, h as TelemetryRateLimitEvent, i as TelemetryRequestEvent, j as TelemetryResponseEvent, k as TelemetryRetryEvent, l as TokenBucketOptions, m as TokenBucketRateLimiter, n as buildAuthorizationUrl, o as defaultRetryClassifier, p as ensureAccessToken, q as exchangeAuthorizationCode, r as fetchWithRetry, s as generateRequestId, t as noopTelemetry, u as refreshTokens, v as sleep, w as withRetry } from './client-CQBMd2Qk.js';

declare const SiteId: z.ZodEnum<{
    MLA: "MLA";
    MLB: "MLB";
    MLM: "MLM";
    MLC: "MLC";
    MCO: "MCO";
    MLU: "MLU";
    MPE: "MPE";
}>;
type SiteId = z.infer<typeof SiteId>;
declare const Currency: z.ZodEnum<{
    ARS: "ARS";
    BRL: "BRL";
    MXN: "MXN";
    CLP: "CLP";
    COP: "COP";
    UYU: "UYU";
    PEN: "PEN";
    USD: "USD";
}>;
type Currency = z.infer<typeof Currency>;
declare const MeliItemId: z.ZodString;
type MeliItemId = z.infer<typeof MeliItemId>;
declare const CategoryId: z.ZodString;
type CategoryId = z.infer<typeof CategoryId>;
declare const ListingType: z.ZodEnum<{
    free: "free";
    bronze: "bronze";
    silver: "silver";
    gold: "gold";
    gold_premium: "gold_premium";
    gold_special: "gold_special";
    gold_pro: "gold_pro";
}>;
type ListingType = z.infer<typeof ListingType>;
declare const ItemStatus: z.ZodEnum<{
    active: "active";
    paused: "paused";
    closed: "closed";
    under_review: "under_review";
    inactive: "inactive";
    payment_required: "payment_required";
    not_yet_active: "not_yet_active";
}>;
type ItemStatus = z.infer<typeof ItemStatus>;
declare const PagingResponse: z.ZodObject<{
    total: z.ZodNumber;
    offset: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type PagingResponse = z.infer<typeof PagingResponse>;
declare const ScrollPagingResponse: z.ZodObject<{
    total: z.ZodNumber;
    scroll_id: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ScrollPagingResponse = z.infer<typeof ScrollPagingResponse>;
declare const Picture: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    url: z.ZodOptional<z.ZodString>;
    secure_url: z.ZodOptional<z.ZodString>;
    size: z.ZodOptional<z.ZodString>;
    max_size: z.ZodOptional<z.ZodString>;
    quality: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type Picture = z.infer<typeof Picture>;
declare const ItemAttribute: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    value_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    value_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    value_struct: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        number: z.ZodOptional<z.ZodNumber>;
        unit: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    attribute_group_id: z.ZodOptional<z.ZodString>;
    attribute_group_name: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ItemAttribute = z.infer<typeof ItemAttribute>;

declare const CategoryPrediction: z.ZodObject<{
    category_id: z.ZodString;
    category_name: z.ZodString;
    domain_id: z.ZodOptional<z.ZodString>;
    domain_name: z.ZodOptional<z.ZodString>;
    prediction_probability: z.ZodOptional<z.ZodNumber>;
    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodOptional<z.ZodString>;
        value_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        value_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        value_struct: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            number: z.ZodOptional<z.ZodNumber>;
            unit: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        attribute_group_id: z.ZodOptional<z.ZodString>;
        attribute_group_name: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    category_path: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type CategoryPrediction = z.infer<typeof CategoryPrediction>;
declare const DomainDiscoveryResult: z.ZodObject<{
    domain_id: z.ZodString;
    domain_name: z.ZodString;
    category_id: z.ZodString;
    category_name: z.ZodString;
    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        value_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        value_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type DomainDiscoveryResult = z.infer<typeof DomainDiscoveryResult>;
declare const TechnicalSpecAttribute: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodOptional<z.ZodString>;
    hierarchy: z.ZodOptional<z.ZodString>;
    relevance: z.ZodOptional<z.ZodNumber>;
    required: z.ZodOptional<z.ZodBoolean>;
    values: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>>>;
    value_type: z.ZodOptional<z.ZodString>;
    value_max_length: z.ZodOptional<z.ZodNumber>;
    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type TechnicalSpecAttribute = z.infer<typeof TechnicalSpecAttribute>;
declare const TechnicalSpecResponse: z.ZodObject<{
    groups: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodOptional<z.ZodString>;
        components: z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodOptional<z.ZodString>;
            hierarchy: z.ZodOptional<z.ZodString>;
            relevance: z.ZodOptional<z.ZodNumber>;
            required: z.ZodOptional<z.ZodBoolean>;
            values: z.ZodOptional<z.ZodArray<z.ZodObject<{
                id: z.ZodOptional<z.ZodString>;
                name: z.ZodOptional<z.ZodString>;
                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, z.core.$strip>>>;
            value_type: z.ZodOptional<z.ZodString>;
            value_max_length: z.ZodOptional<z.ZodNumber>;
            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type TechnicalSpecResponse = z.infer<typeof TechnicalSpecResponse>;
declare const CategoryMetadata: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    picture: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    permalink: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    total_items_in_this_category: z.ZodOptional<z.ZodNumber>;
    path_from_root: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
    }, z.core.$strip>>>;
    children_categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
    }, z.core.$strip>>>;
    attribute_types: z.ZodOptional<z.ZodString>;
    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodOptional<z.ZodString>;
        hierarchy: z.ZodOptional<z.ZodString>;
        relevance: z.ZodOptional<z.ZodNumber>;
        required: z.ZodOptional<z.ZodBoolean>;
        values: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodOptional<z.ZodString>;
            name: z.ZodOptional<z.ZodString>;
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>>;
        value_type: z.ZodOptional<z.ZodString>;
        value_max_length: z.ZodOptional<z.ZodNumber>;
        tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, z.core.$strip>>>;
    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strip>;
type CategoryMetadata = z.infer<typeof CategoryMetadata>;

declare const QuestionStatus: z.ZodEnum<{
    ANSWERED: "ANSWERED";
    UNANSWERED: "UNANSWERED";
    CLOSED_UNANSWERED: "CLOSED_UNANSWERED";
    UNDER_REVIEW: "UNDER_REVIEW";
    BANNED: "BANNED";
    DELETED: "DELETED";
    DISABLED: "DISABLED";
}>;
type QuestionStatus = z.infer<typeof QuestionStatus>;
declare const Answer: z.ZodObject<{
    text: z.ZodString;
    status: z.ZodOptional<z.ZodEnum<{
        UNDER_REVIEW: "UNDER_REVIEW";
        DELETED: "DELETED";
        DISABLED: "DISABLED";
        ACTIVE: "ACTIVE";
    }>>;
    date_created: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type Answer = z.infer<typeof Answer>;
declare const Question: z.ZodObject<{
    id: z.ZodNumber;
    date_created: z.ZodString;
    item_id: z.ZodString;
    seller_id: z.ZodNumber;
    status: z.ZodEnum<{
        ANSWERED: "ANSWERED";
        UNANSWERED: "UNANSWERED";
        CLOSED_UNANSWERED: "CLOSED_UNANSWERED";
        UNDER_REVIEW: "UNDER_REVIEW";
        BANNED: "BANNED";
        DELETED: "DELETED";
        DISABLED: "DISABLED";
    }>;
    text: z.ZodString;
    answer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        text: z.ZodString;
        status: z.ZodOptional<z.ZodEnum<{
            UNDER_REVIEW: "UNDER_REVIEW";
            DELETED: "DELETED";
            DISABLED: "DISABLED";
            ACTIVE: "ACTIVE";
        }>>;
        date_created: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    deleted_from_listing: z.ZodOptional<z.ZodBoolean>;
    hold: z.ZodOptional<z.ZodBoolean>;
    from: z.ZodOptional<z.ZodObject<{
        id: z.ZodNumber;
        answered_questions: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Question = z.infer<typeof Question>;
declare const QuestionsSearchResponse: z.ZodObject<{
    questions: z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        date_created: z.ZodString;
        item_id: z.ZodString;
        seller_id: z.ZodNumber;
        status: z.ZodEnum<{
            ANSWERED: "ANSWERED";
            UNANSWERED: "UNANSWERED";
            CLOSED_UNANSWERED: "CLOSED_UNANSWERED";
            UNDER_REVIEW: "UNDER_REVIEW";
            BANNED: "BANNED";
            DELETED: "DELETED";
            DISABLED: "DISABLED";
        }>;
        text: z.ZodString;
        answer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            text: z.ZodString;
            status: z.ZodOptional<z.ZodEnum<{
                UNDER_REVIEW: "UNDER_REVIEW";
                DELETED: "DELETED";
                DISABLED: "DISABLED";
                ACTIVE: "ACTIVE";
            }>>;
            date_created: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        deleted_from_listing: z.ZodOptional<z.ZodBoolean>;
        hold: z.ZodOptional<z.ZodBoolean>;
        from: z.ZodOptional<z.ZodObject<{
            id: z.ZodNumber;
            answered_questions: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    total: z.ZodNumber;
    limit: z.ZodOptional<z.ZodNumber>;
    offset: z.ZodOptional<z.ZodNumber>;
    filters: z.ZodOptional<z.ZodUnknown>;
    available_filters: z.ZodOptional<z.ZodUnknown>;
    available_sorts: z.ZodOptional<z.ZodUnknown>;
}, z.core.$strip>;
type QuestionsSearchResponse = z.infer<typeof QuestionsSearchResponse>;
declare const AnswerRequest: z.ZodObject<{
    question_id: z.ZodNumber;
    text: z.ZodString;
}, z.core.$strip>;
type AnswerRequest = z.infer<typeof AnswerRequest>;
declare const QuestionSpamFeatures: z.ZodObject<{
    asker_account_age_days: z.ZodOptional<z.ZodNumber>;
    asker_answered_questions: z.ZodOptional<z.ZodNumber>;
    contains_external_contact: z.ZodBoolean;
    cross_listing_repetition: z.ZodBoolean;
    text_length: z.ZodNumber;
}, z.core.$strip>;
type QuestionSpamFeatures = z.infer<typeof QuestionSpamFeatures>;

declare const OrderStatus: z.ZodEnum<{
    payment_required: "payment_required";
    paid: "paid";
    confirmed: "confirmed";
    cancelled: "cancelled";
    payment_in_process: "payment_in_process";
    partially_paid: "partially_paid";
    invalid: "invalid";
}>;
type OrderStatus = z.infer<typeof OrderStatus>;
declare const OrderItem: z.ZodObject<{
    item: z.ZodObject<{
        id: z.ZodString;
        title: z.ZodString;
        category_id: z.ZodOptional<z.ZodString>;
        variation_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
        seller_custom_field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        variation_attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            id: z.ZodString;
            value_name: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        warranty: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        condition: z.ZodOptional<z.ZodEnum<{
            new: "new";
            used: "used";
            not_specified: "not_specified";
        }>>;
    }, z.core.$strip>;
    quantity: z.ZodNumber;
    unit_price: z.ZodNumber;
    full_unit_price: z.ZodOptional<z.ZodNumber>;
    currency_id: z.ZodEnum<{
        ARS: "ARS";
        BRL: "BRL";
        MXN: "MXN";
        CLP: "CLP";
        COP: "COP";
        UYU: "UYU";
        PEN: "PEN";
        USD: "USD";
    }>;
    manufacturing_days: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    sale_fee: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    listing_type_id: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type OrderItem = z.infer<typeof OrderItem>;
declare const OrderPayment: z.ZodObject<{
    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
    status: z.ZodOptional<z.ZodEnum<{
        cancelled: "cancelled";
        pending: "pending";
        approved: "approved";
        authorized: "authorized";
        in_process: "in_process";
        in_mediation: "in_mediation";
        rejected: "rejected";
        refunded: "refunded";
        charged_back: "charged_back";
    }>>;
    status_detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    transaction_amount: z.ZodOptional<z.ZodNumber>;
    total_paid_amount: z.ZodOptional<z.ZodNumber>;
    currency_id: z.ZodOptional<z.ZodEnum<{
        ARS: "ARS";
        BRL: "BRL";
        MXN: "MXN";
        CLP: "CLP";
        COP: "COP";
        UYU: "UYU";
        PEN: "PEN";
        USD: "USD";
    }>>;
    payer_id: z.ZodOptional<z.ZodNumber>;
    installments: z.ZodOptional<z.ZodNumber>;
    payment_method_id: z.ZodOptional<z.ZodString>;
    payment_type: z.ZodOptional<z.ZodString>;
    date_approved: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    date_created: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type OrderPayment = z.infer<typeof OrderPayment>;
declare const OrderBuyer: z.ZodObject<{
    id: z.ZodNumber;
    nickname: z.ZodOptional<z.ZodString>;
    first_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    last_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    billing_info: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        doc_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        doc_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type OrderBuyer = z.infer<typeof OrderBuyer>;
declare const Order: z.ZodObject<{
    id: z.ZodNumber;
    date_created: z.ZodString;
    date_closed: z.ZodOptional<z.ZodString>;
    last_updated: z.ZodOptional<z.ZodString>;
    expiration_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    status: z.ZodEnum<{
        payment_required: "payment_required";
        paid: "paid";
        confirmed: "confirmed";
        cancelled: "cancelled";
        payment_in_process: "payment_in_process";
        partially_paid: "partially_paid";
        invalid: "invalid";
    }>;
    status_detail: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    total_amount: z.ZodNumber;
    paid_amount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    currency_id: z.ZodEnum<{
        ARS: "ARS";
        BRL: "BRL";
        MXN: "MXN";
        CLP: "CLP";
        COP: "COP";
        UYU: "UYU";
        PEN: "PEN";
        USD: "USD";
    }>;
    pack_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    pickup_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    fulfilled: z.ZodOptional<z.ZodBoolean>;
    shipping: z.ZodOptional<z.ZodObject<{
        id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    }, z.core.$strip>>;
    order_items: z.ZodArray<z.ZodObject<{
        item: z.ZodObject<{
            id: z.ZodString;
            title: z.ZodString;
            category_id: z.ZodOptional<z.ZodString>;
            variation_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
            seller_custom_field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            variation_attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                name: z.ZodString;
                id: z.ZodString;
                value_name: z.ZodOptional<z.ZodString>;
            }, z.core.$strip>>>;
            warranty: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            condition: z.ZodOptional<z.ZodEnum<{
                new: "new";
                used: "used";
                not_specified: "not_specified";
            }>>;
        }, z.core.$strip>;
        quantity: z.ZodNumber;
        unit_price: z.ZodNumber;
        full_unit_price: z.ZodOptional<z.ZodNumber>;
        currency_id: z.ZodEnum<{
            ARS: "ARS";
            BRL: "BRL";
            MXN: "MXN";
            CLP: "CLP";
            COP: "COP";
            UYU: "UYU";
            PEN: "PEN";
            USD: "USD";
        }>;
        manufacturing_days: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        sale_fee: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        listing_type_id: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    payments: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
        status: z.ZodOptional<z.ZodEnum<{
            cancelled: "cancelled";
            pending: "pending";
            approved: "approved";
            authorized: "authorized";
            in_process: "in_process";
            in_mediation: "in_mediation";
            rejected: "rejected";
            refunded: "refunded";
            charged_back: "charged_back";
        }>>;
        status_detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        transaction_amount: z.ZodOptional<z.ZodNumber>;
        total_paid_amount: z.ZodOptional<z.ZodNumber>;
        currency_id: z.ZodOptional<z.ZodEnum<{
            ARS: "ARS";
            BRL: "BRL";
            MXN: "MXN";
            CLP: "CLP";
            COP: "COP";
            UYU: "UYU";
            PEN: "PEN";
            USD: "USD";
        }>>;
        payer_id: z.ZodOptional<z.ZodNumber>;
        installments: z.ZodOptional<z.ZodNumber>;
        payment_method_id: z.ZodOptional<z.ZodString>;
        payment_type: z.ZodOptional<z.ZodString>;
        date_approved: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        date_created: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    buyer: z.ZodObject<{
        id: z.ZodNumber;
        nickname: z.ZodOptional<z.ZodString>;
        first_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        last_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        billing_info: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            doc_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            doc_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>>>;
    }, z.core.$strip>;
    seller: z.ZodOptional<z.ZodObject<{
        id: z.ZodNumber;
        nickname: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    feedback: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
    manufacturing_ending_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    application_id: z.ZodOptional<z.ZodString>;
    context: z.ZodOptional<z.ZodObject<{
        channel: z.ZodOptional<z.ZodString>;
        site: z.ZodOptional<z.ZodString>;
        flows: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Order = z.infer<typeof Order>;
declare const OrdersSearchResponse: z.ZodObject<{
    results: z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        date_created: z.ZodString;
        date_closed: z.ZodOptional<z.ZodString>;
        last_updated: z.ZodOptional<z.ZodString>;
        expiration_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        status: z.ZodEnum<{
            payment_required: "payment_required";
            paid: "paid";
            confirmed: "confirmed";
            cancelled: "cancelled";
            payment_in_process: "payment_in_process";
            partially_paid: "partially_paid";
            invalid: "invalid";
        }>;
        status_detail: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
        total_amount: z.ZodNumber;
        paid_amount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        currency_id: z.ZodEnum<{
            ARS: "ARS";
            BRL: "BRL";
            MXN: "MXN";
            CLP: "CLP";
            COP: "COP";
            UYU: "UYU";
            PEN: "PEN";
            USD: "USD";
        }>;
        pack_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        pickup_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        fulfilled: z.ZodOptional<z.ZodBoolean>;
        shipping: z.ZodOptional<z.ZodObject<{
            id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        }, z.core.$strip>>;
        order_items: z.ZodArray<z.ZodObject<{
            item: z.ZodObject<{
                id: z.ZodString;
                title: z.ZodString;
                category_id: z.ZodOptional<z.ZodString>;
                variation_id: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
                seller_custom_field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                variation_attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
                    name: z.ZodString;
                    id: z.ZodString;
                    value_name: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                warranty: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                condition: z.ZodOptional<z.ZodEnum<{
                    new: "new";
                    used: "used";
                    not_specified: "not_specified";
                }>>;
            }, z.core.$strip>;
            quantity: z.ZodNumber;
            unit_price: z.ZodNumber;
            full_unit_price: z.ZodOptional<z.ZodNumber>;
            currency_id: z.ZodEnum<{
                ARS: "ARS";
                BRL: "BRL";
                MXN: "MXN";
                CLP: "CLP";
                COP: "COP";
                UYU: "UYU";
                PEN: "PEN";
                USD: "USD";
            }>;
            manufacturing_days: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            sale_fee: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            listing_type_id: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        payments: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
            status: z.ZodOptional<z.ZodEnum<{
                cancelled: "cancelled";
                pending: "pending";
                approved: "approved";
                authorized: "authorized";
                in_process: "in_process";
                in_mediation: "in_mediation";
                rejected: "rejected";
                refunded: "refunded";
                charged_back: "charged_back";
            }>>;
            status_detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            transaction_amount: z.ZodOptional<z.ZodNumber>;
            total_paid_amount: z.ZodOptional<z.ZodNumber>;
            currency_id: z.ZodOptional<z.ZodEnum<{
                ARS: "ARS";
                BRL: "BRL";
                MXN: "MXN";
                CLP: "CLP";
                COP: "COP";
                UYU: "UYU";
                PEN: "PEN";
                USD: "USD";
            }>>;
            payer_id: z.ZodOptional<z.ZodNumber>;
            installments: z.ZodOptional<z.ZodNumber>;
            payment_method_id: z.ZodOptional<z.ZodString>;
            payment_type: z.ZodOptional<z.ZodString>;
            date_approved: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            date_created: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        buyer: z.ZodObject<{
            id: z.ZodNumber;
            nickname: z.ZodOptional<z.ZodString>;
            first_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            last_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            billing_info: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                doc_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                doc_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            }, z.core.$strip>>>;
        }, z.core.$strip>;
        seller: z.ZodOptional<z.ZodObject<{
            id: z.ZodNumber;
            nickname: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        feedback: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        manufacturing_ending_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        application_id: z.ZodOptional<z.ZodString>;
        context: z.ZodOptional<z.ZodObject<{
            channel: z.ZodOptional<z.ZodString>;
            site: z.ZodOptional<z.ZodString>;
            flows: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    paging: z.ZodObject<{
        total: z.ZodNumber;
        offset: z.ZodOptional<z.ZodNumber>;
        limit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
}, z.core.$strip>;
type OrdersSearchResponse = z.infer<typeof OrdersSearchResponse>;
declare const Pack: z.ZodObject<{
    id: z.ZodNumber;
    status: z.ZodString;
    orders: z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        buyer: z.ZodOptional<z.ZodObject<{
            id: z.ZodNumber;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    shipment: z.ZodOptional<z.ZodObject<{
        id: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strip>;
type Pack = z.infer<typeof Pack>;

declare const ClaimStage: z.ZodEnum<{
    cancelled: "cancelled";
    claim: "claim";
    dispute: "dispute";
    mediation: "mediation";
    resolved: "resolved";
}>;
type ClaimStage = z.infer<typeof ClaimStage>;
declare const ClaimStatus: z.ZodEnum<{
    closed: "closed";
    opened: "opened";
    expired: "expired";
    potential_claim: "potential_claim";
}>;
type ClaimStatus = z.infer<typeof ClaimStatus>;
declare const ClaimReason: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    detail: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ClaimReason = z.infer<typeof ClaimReason>;
declare const ClaimPlayer: z.ZodObject<{
    role: z.ZodEnum<{
        complainant: "complainant";
        respondent: "respondent";
        mediator: "mediator";
    }>;
    type: z.ZodEnum<{
        buyer: "buyer";
        seller: "seller";
        ml: "ml";
    }>;
    user_id: z.ZodNumber;
    available_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type ClaimPlayer = z.infer<typeof ClaimPlayer>;
declare const Claim: z.ZodObject<{
    id: z.ZodNumber;
    resource: z.ZodEnum<{
        order: "order";
        shipment: "shipment";
        payment: "payment";
    }>;
    resource_id: z.ZodNumber;
    status: z.ZodEnum<{
        closed: "closed";
        opened: "opened";
        expired: "expired";
        potential_claim: "potential_claim";
    }>;
    stage: z.ZodEnum<{
        cancelled: "cancelled";
        claim: "claim";
        dispute: "dispute";
        mediation: "mediation";
        resolved: "resolved";
    }>;
    parent_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    type: z.ZodOptional<z.ZodString>;
    reason_id: z.ZodOptional<z.ZodString>;
    reason: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        detail: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    fulfilled: z.ZodOptional<z.ZodBoolean>;
    quantity_type: z.ZodOptional<z.ZodString>;
    date_created: z.ZodString;
    last_updated: z.ZodOptional<z.ZodString>;
    resolution: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        decision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        benefited: z.ZodOptional<z.ZodArray<z.ZodString>>;
        date_created: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    players: z.ZodOptional<z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<{
            complainant: "complainant";
            respondent: "respondent";
            mediator: "mediator";
        }>;
        type: z.ZodEnum<{
            buyer: "buyer";
            seller: "seller";
            ml: "ml";
        }>;
        user_id: z.ZodNumber;
        available_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>>;
    related_entities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
    site_id: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type Claim = z.infer<typeof Claim>;
declare const EvidenceType: z.ZodEnum<{
    PROOF_OF_SHIPMENT: "PROOF_OF_SHIPMENT";
    ITEM_DESCRIPTION_VS_RECEIVED: "ITEM_DESCRIPTION_VS_RECEIVED";
    VIDEO_OF_PRODUCT: "VIDEO_OF_PRODUCT";
    INVOICE: "INVOICE";
    MESSAGE_THREAD: "MESSAGE_THREAD";
    DELIVERY_PROOF: "DELIVERY_PROOF";
    RETURN_PROOF: "RETURN_PROOF";
    OTHER: "OTHER";
}>;
type EvidenceType = z.infer<typeof EvidenceType>;
declare const ClaimEvidence: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    type: z.ZodEnum<{
        PROOF_OF_SHIPMENT: "PROOF_OF_SHIPMENT";
        ITEM_DESCRIPTION_VS_RECEIVED: "ITEM_DESCRIPTION_VS_RECEIVED";
        VIDEO_OF_PRODUCT: "VIDEO_OF_PRODUCT";
        INVOICE: "INVOICE";
        MESSAGE_THREAD: "MESSAGE_THREAD";
        DELIVERY_PROOF: "DELIVERY_PROOF";
        RETURN_PROOF: "RETURN_PROOF";
        OTHER: "OTHER";
    }>;
    text: z.ZodOptional<z.ZodString>;
    attachment_url: z.ZodOptional<z.ZodString>;
    attachment_id: z.ZodOptional<z.ZodString>;
    date_created: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ClaimEvidence = z.infer<typeof ClaimEvidence>;
declare const EvidenceUploadRequest: z.ZodObject<{
    evidence_type: z.ZodEnum<{
        PROOF_OF_SHIPMENT: "PROOF_OF_SHIPMENT";
        ITEM_DESCRIPTION_VS_RECEIVED: "ITEM_DESCRIPTION_VS_RECEIVED";
        VIDEO_OF_PRODUCT: "VIDEO_OF_PRODUCT";
        INVOICE: "INVOICE";
        MESSAGE_THREAD: "MESSAGE_THREAD";
        DELIVERY_PROOF: "DELIVERY_PROOF";
        RETURN_PROOF: "RETURN_PROOF";
        OTHER: "OTHER";
    }>;
    text: z.ZodOptional<z.ZodString>;
    attachment_id: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type EvidenceUploadRequest = z.infer<typeof EvidenceUploadRequest>;
declare const ClaimMessage: z.ZodObject<{
    id: z.ZodOptional<z.ZodString>;
    date: z.ZodOptional<z.ZodString>;
    sender_role: z.ZodOptional<z.ZodEnum<{
        complainant: "complainant";
        respondent: "respondent";
        mediator: "mediator";
    }>>;
    sender_user_id: z.ZodOptional<z.ZodNumber>;
    message: z.ZodString;
    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
        url: z.ZodOptional<z.ZodString>;
        name: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type ClaimMessage = z.infer<typeof ClaimMessage>;

declare const ReputationLevel: z.ZodEnum<{
    "5_green": "5_green";
    "4_light_green": "4_light_green";
    "3_yellow": "3_yellow";
    "2_orange": "2_orange";
    "1_red": "1_red";
    newbie: "newbie";
}>;
type ReputationLevel = z.infer<typeof ReputationLevel>;
declare const PowerSellerStatus: z.ZodNullable<z.ZodEnum<{
    silver: "silver";
    gold: "gold";
    platinum: "platinum";
}>>;
type PowerSellerStatus = z.infer<typeof PowerSellerStatus>;
declare const ReputationMetric: z.ZodObject<{
    rate: z.ZodOptional<z.ZodNumber>;
    value: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ReputationMetric = z.infer<typeof ReputationMetric>;
declare const ReputationMetrics: z.ZodObject<{
    claims: z.ZodOptional<z.ZodObject<{
        rate: z.ZodOptional<z.ZodNumber>;
        value: z.ZodOptional<z.ZodNumber>;
        period: z.ZodOptional<z.ZodString>;
        excluded: z.ZodOptional<z.ZodUnknown>;
    }, z.core.$strip>>;
    delayed_handling_time: z.ZodOptional<z.ZodObject<{
        rate: z.ZodOptional<z.ZodNumber>;
        value: z.ZodOptional<z.ZodNumber>;
        period: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    cancellations: z.ZodOptional<z.ZodObject<{
        rate: z.ZodOptional<z.ZodNumber>;
        value: z.ZodOptional<z.ZodNumber>;
        period: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    sales: z.ZodOptional<z.ZodObject<{
        period: z.ZodOptional<z.ZodString>;
        completed: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ReputationMetrics = z.infer<typeof ReputationMetrics>;
declare const SellerReputation: z.ZodObject<{
    level_id: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        "5_green": "5_green";
        "4_light_green": "4_light_green";
        "3_yellow": "3_yellow";
        "2_orange": "2_orange";
        "1_red": "1_red";
        newbie: "newbie";
    }>>>;
    power_seller_status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
        silver: "silver";
        gold: "gold";
        platinum: "platinum";
    }>>>;
    protection_end_date: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    status: z.ZodOptional<z.ZodObject<{
        list: z.ZodOptional<z.ZodObject<{
            allow: z.ZodOptional<z.ZodBoolean>;
            codes: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        buy: z.ZodOptional<z.ZodObject<{
            allow: z.ZodOptional<z.ZodBoolean>;
            codes: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        sell: z.ZodOptional<z.ZodObject<{
            allow: z.ZodOptional<z.ZodBoolean>;
            codes: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
        billing: z.ZodOptional<z.ZodObject<{
            allow: z.ZodOptional<z.ZodBoolean>;
            codes: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    transactions: z.ZodOptional<z.ZodObject<{
        canceled: z.ZodOptional<z.ZodNumber>;
        completed: z.ZodOptional<z.ZodNumber>;
        period: z.ZodOptional<z.ZodString>;
        ratings: z.ZodOptional<z.ZodObject<{
            negative: z.ZodOptional<z.ZodNumber>;
            neutral: z.ZodOptional<z.ZodNumber>;
            positive: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>>;
        total: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    metrics: z.ZodOptional<z.ZodObject<{
        claims: z.ZodOptional<z.ZodObject<{
            rate: z.ZodOptional<z.ZodNumber>;
            value: z.ZodOptional<z.ZodNumber>;
            period: z.ZodOptional<z.ZodString>;
            excluded: z.ZodOptional<z.ZodUnknown>;
        }, z.core.$strip>>;
        delayed_handling_time: z.ZodOptional<z.ZodObject<{
            rate: z.ZodOptional<z.ZodNumber>;
            value: z.ZodOptional<z.ZodNumber>;
            period: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        cancellations: z.ZodOptional<z.ZodObject<{
            rate: z.ZodOptional<z.ZodNumber>;
            value: z.ZodOptional<z.ZodNumber>;
            period: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        sales: z.ZodOptional<z.ZodObject<{
            period: z.ZodOptional<z.ZodString>;
            completed: z.ZodOptional<z.ZodNumber>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type SellerReputation = z.infer<typeof SellerReputation>;
declare const ReputationAlertSeverity: z.ZodEnum<{
    info: "info";
    warning: "warning";
    critical: "critical";
}>;
type ReputationAlertSeverity = z.infer<typeof ReputationAlertSeverity>;
declare const ReputationAlert: z.ZodObject<{
    severity: z.ZodEnum<{
        info: "info";
        warning: "warning";
        critical: "critical";
    }>;
    title: z.ZodString;
    detail: z.ZodString;
    metric: z.ZodOptional<z.ZodString>;
    current_value: z.ZodOptional<z.ZodNumber>;
    threshold: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type ReputationAlert = z.infer<typeof ReputationAlert>;

declare const PromotionType: z.ZodEnum<{
    DEAL: "DEAL";
    DOD: "DOD";
    LIGHTNING: "LIGHTNING";
    SMART: "SMART";
    PRICE_DISCOUNT: "PRICE_DISCOUNT";
    SELLER_COUPON_CAMPAIGN: "SELLER_COUPON_CAMPAIGN";
    MARKETPLACE_CAMPAIGN: "MARKETPLACE_CAMPAIGN";
    PRICE_MATCHING: "PRICE_MATCHING";
    UNHEALTHY_STOCK: "UNHEALTHY_STOCK";
    VOLUME: "VOLUME";
    PRE_NEGOTIATED: "PRE_NEGOTIATED";
}>;
type PromotionType = z.infer<typeof PromotionType>;
declare const PromotionCandidate: z.ZodObject<{
    promotion_id: z.ZodString;
    promotion_type: z.ZodUnion<readonly [z.ZodEnum<{
        DEAL: "DEAL";
        DOD: "DOD";
        LIGHTNING: "LIGHTNING";
        SMART: "SMART";
        PRICE_DISCOUNT: "PRICE_DISCOUNT";
        SELLER_COUPON_CAMPAIGN: "SELLER_COUPON_CAMPAIGN";
        MARKETPLACE_CAMPAIGN: "MARKETPLACE_CAMPAIGN";
        PRICE_MATCHING: "PRICE_MATCHING";
        UNHEALTHY_STOCK: "UNHEALTHY_STOCK";
        VOLUME: "VOLUME";
        PRE_NEGOTIATED: "PRE_NEGOTIATED";
    }>, z.ZodString]>;
    start_date: z.ZodOptional<z.ZodString>;
    finish_date: z.ZodOptional<z.ZodString>;
    suggested_discount_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    max_discount_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    min_discount_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        original_price: z.ZodOptional<z.ZodNumber>;
        suggested_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        max_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        min_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        currency_id: z.ZodOptional<z.ZodEnum<{
            ARS: "ARS";
            BRL: "BRL";
            MXN: "MXN";
            CLP: "CLP";
            COP: "COP";
            UYU: "UYU";
            PEN: "PEN";
            USD: "USD";
        }>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
type PromotionCandidate = z.infer<typeof PromotionCandidate>;
declare const PromotionOptInRequest: z.ZodObject<{
    promotion_id: z.ZodString;
    promotion_type: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
        DEAL: "DEAL";
        DOD: "DOD";
        LIGHTNING: "LIGHTNING";
        SMART: "SMART";
        PRICE_DISCOUNT: "PRICE_DISCOUNT";
        SELLER_COUPON_CAMPAIGN: "SELLER_COUPON_CAMPAIGN";
        MARKETPLACE_CAMPAIGN: "MARKETPLACE_CAMPAIGN";
        PRICE_MATCHING: "PRICE_MATCHING";
        UNHEALTHY_STOCK: "UNHEALTHY_STOCK";
        VOLUME: "VOLUME";
        PRE_NEGOTIATED: "PRE_NEGOTIATED";
    }>, z.ZodString]>>;
    deal_price: z.ZodNumber;
}, z.core.$strip>;
type PromotionOptInRequest = z.infer<typeof PromotionOptInRequest>;
declare const PromotionOptInResponse: z.ZodObject<{
    id: z.ZodString;
    status: z.ZodOptional<z.ZodEnum<{
        rejected: "rejected";
        started: "started";
        finished: "finished";
        candidate: "candidate";
    }>>;
    promotion_id: z.ZodOptional<z.ZodString>;
    deal_price: z.ZodOptional<z.ZodNumber>;
    original_price: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type PromotionOptInResponse = z.infer<typeof PromotionOptInResponse>;

declare const MeliWebhookTopic: z.ZodEnum<{
    questions: "questions";
    payments: "payments";
    orders: "orders";
    claims: "claims";
    items: "items";
    orders_v2: "orders_v2";
    marketplace_orders: "marketplace_orders";
    items_prices: "items_prices";
    messages: "messages";
    shipments: "shipments";
    fbm_stock_operations: "fbm_stock_operations";
    stock_locations: "stock_locations";
    public_offers: "public_offers";
    public_candidates: "public_candidates";
    item_competition_status: "item_competition_status";
    catalog_suggestions: "catalog_suggestions";
    orders_feedback: "orders_feedback";
    leads_credits: "leads_credits";
    vis_leads: "vis_leads";
    post_purchase: "post_purchase";
    marketplace_questions: "marketplace_questions";
    marketplace_messages: "marketplace_messages";
    marketplace_claims: "marketplace_claims";
    marketplace_items: "marketplace_items";
}>;
type MeliWebhookTopic = z.infer<typeof MeliWebhookTopic>;
declare const MeliWebhookEvent: z.ZodObject<{
    _id: z.ZodOptional<z.ZodString>;
    resource: z.ZodString;
    user_id: z.ZodNumber;
    topic: z.ZodUnion<readonly [z.ZodEnum<{
        questions: "questions";
        payments: "payments";
        orders: "orders";
        claims: "claims";
        items: "items";
        orders_v2: "orders_v2";
        marketplace_orders: "marketplace_orders";
        items_prices: "items_prices";
        messages: "messages";
        shipments: "shipments";
        fbm_stock_operations: "fbm_stock_operations";
        stock_locations: "stock_locations";
        public_offers: "public_offers";
        public_candidates: "public_candidates";
        item_competition_status: "item_competition_status";
        catalog_suggestions: "catalog_suggestions";
        orders_feedback: "orders_feedback";
        leads_credits: "leads_credits";
        vis_leads: "vis_leads";
        post_purchase: "post_purchase";
        marketplace_questions: "marketplace_questions";
        marketplace_messages: "marketplace_messages";
        marketplace_claims: "marketplace_claims";
        marketplace_items: "marketplace_items";
    }>, z.ZodString]>;
    application_id: z.ZodOptional<z.ZodNumber>;
    attempts: z.ZodOptional<z.ZodNumber>;
    sent: z.ZodOptional<z.ZodString>;
    received: z.ZodOptional<z.ZodString>;
    actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
type MeliWebhookEvent = z.infer<typeof MeliWebhookEvent>;
declare const MissedFeed: z.ZodObject<{
    resource: z.ZodString;
    user_id: z.ZodNumber;
    topic: z.ZodUnion<readonly [z.ZodEnum<{
        questions: "questions";
        payments: "payments";
        orders: "orders";
        claims: "claims";
        items: "items";
        orders_v2: "orders_v2";
        marketplace_orders: "marketplace_orders";
        items_prices: "items_prices";
        messages: "messages";
        shipments: "shipments";
        fbm_stock_operations: "fbm_stock_operations";
        stock_locations: "stock_locations";
        public_offers: "public_offers";
        public_candidates: "public_candidates";
        item_competition_status: "item_competition_status";
        catalog_suggestions: "catalog_suggestions";
        orders_feedback: "orders_feedback";
        leads_credits: "leads_credits";
        vis_leads: "vis_leads";
        post_purchase: "post_purchase";
        marketplace_questions: "marketplace_questions";
        marketplace_messages: "marketplace_messages";
        marketplace_claims: "marketplace_claims";
        marketplace_items: "marketplace_items";
    }>, z.ZodString]>;
    application_id: z.ZodOptional<z.ZodNumber>;
    sent: z.ZodOptional<z.ZodString>;
    attempts: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>;
type MissedFeed = z.infer<typeof MissedFeed>;
declare const MissedFeedsResponse: z.ZodArray<z.ZodObject<{
    resource: z.ZodString;
    user_id: z.ZodNumber;
    topic: z.ZodUnion<readonly [z.ZodEnum<{
        questions: "questions";
        payments: "payments";
        orders: "orders";
        claims: "claims";
        items: "items";
        orders_v2: "orders_v2";
        marketplace_orders: "marketplace_orders";
        items_prices: "items_prices";
        messages: "messages";
        shipments: "shipments";
        fbm_stock_operations: "fbm_stock_operations";
        stock_locations: "stock_locations";
        public_offers: "public_offers";
        public_candidates: "public_candidates";
        item_competition_status: "item_competition_status";
        catalog_suggestions: "catalog_suggestions";
        orders_feedback: "orders_feedback";
        leads_credits: "leads_credits";
        vis_leads: "vis_leads";
        post_purchase: "post_purchase";
        marketplace_questions: "marketplace_questions";
        marketplace_messages: "marketplace_messages";
        marketplace_claims: "marketplace_claims";
        marketplace_items: "marketplace_items";
    }>, z.ZodString]>;
    application_id: z.ZodOptional<z.ZodNumber>;
    sent: z.ZodOptional<z.ZodString>;
    attempts: z.ZodOptional<z.ZodNumber>;
}, z.core.$strip>>;
type MissedFeedsResponse = z.infer<typeof MissedFeedsResponse>;

/** Common base. */
declare abstract class MeliError extends ArAgentsError {
    abstract readonly code: string;
    constructor(message: string, init?: {
        retryable?: boolean;
        context?: Record<string, unknown>;
        cause?: unknown;
    });
}
/** Shape of MELI's typical error envelope. The fields are not guaranteed —
 *  legacy endpoints sometimes use `{ status, message }` only, and some
 *  post-purchase routes return `{ error_code, description }`. We extract
 *  both shapes opportunistically. */
interface MeliErrorBody {
    /** MELI's machine-readable error slug (e.g., "rate_limited",
     *  "forbidden", "validation_error"). */
    error?: string;
    /** Human-readable message MELI returns alongside `error`. */
    message?: string;
    /** Echoed status code (some MELI endpoints duplicate it in the body). */
    status?: number;
    /** Multi-issue causes — typically array of `{ code, message }` for
     *  validation failures on `createItem` / `updateItem`. */
    cause?: Array<{
        code?: string | number;
        message?: string;
        [k: string]: unknown;
    }>;
}
/** A MELI API call returned a non-2xx after retries are exhausted. */
declare class MeliApiError extends MeliError {
    readonly status: number;
    readonly url: string;
    readonly body: unknown;
    readonly requestId?: string | undefined;
    readonly code = "meli_api_error";
    /** MELI's error slug if present (`error` field on the body). Stable +
     *  documented; safe to switch on in your code. */
    readonly meliCode: string | null;
    /** MELI's human-readable error message if present. */
    readonly meliMessage: string | null;
    /** Multi-issue causes (validation failures usually). */
    readonly meliCauses: ReadonlyArray<{
        code?: string | number;
        message?: string;
        [k: string]: unknown;
    }>;
    constructor(message: string, status: number, url: string, body: unknown, requestId?: string | undefined);
    /** Back-compat — same as `meliCode`. New code should read `meliCode` directly. */
    meliErrorCode(): string | null;
    /**
     * True if MELI explicitly told us this was a rate-limit hit
     * (vs. a 429 with no body, or a 5xx). Use this to drive a longer backoff
     * in your retry loop.
     */
    isRateLimited(): boolean;
    /**
     * True if the request hit the seller's permission boundary — typically
     * because the bearer token doesn't own the resource being addressed.
     * Don't retry; surface to the user.
     */
    isForbidden(): boolean;
    /**
     * True if MELI says this access_token is invalid / expired.
     * The OAuth flow's `ensureAccessToken` should be re-driven before retrying.
     */
    isUnauthorized(): boolean;
    /** True if MELI's body identifies this as validation-failure on inputs. */
    isValidationError(): boolean;
}
/** OAuth-related failure (token refresh, callback, etc.). */
declare class MeliAuthError extends MeliError {
    readonly cause?: unknown | undefined;
    readonly code = "meli_auth_error";
    constructor(message: string, cause?: unknown | undefined);
}
/** Rate limit hit and retries are exhausted. */
declare class MeliRateLimitError extends MeliError {
    readonly retryAfterSeconds: number;
    readonly url: string;
    readonly code = "meli_rate_limit";
    constructor(retryAfterSeconds: number, url: string);
}
/** The host's network failed (DNS, TLS, fetch threw). */
declare class MeliNetworkError extends MeliError {
    readonly cause?: unknown | undefined;
    readonly code = "meli_network_error";
    constructor(message: string, cause?: unknown | undefined);
}
/** A response body failed Zod validation. */
declare class MeliValidationError extends MeliError {
    readonly issues: unknown;
    readonly code = "meli_validation_error";
    constructor(message: string, issues: unknown);
}
/** Webhook signature verification failed (where ML supports it). */
declare class MeliWebhookError extends MeliError {
    readonly detail: "missing_topic" | "missing_resource" | "unknown_topic" | "malformed_body" | "missed_feeds_unauthorized";
    readonly code = "meli_webhook_error";
    constructor(detail: "missing_topic" | "missing_resource" | "unknown_topic" | "malformed_body" | "missed_feeds_unauthorized", message: string);
}
/** Convenience type guard. */
declare function isMeliError(e: unknown): e is MeliError;

interface GetItemOptions {
    /** Optionally project a subset of fields via the `attributes` param. */
    attributes?: string[];
    /** Include catalog data in the response. */
    includeCatalog?: boolean;
}
declare function getItem(client: MeliClient, itemId: string, options?: GetItemOptions): Promise<Item>;
interface MultigetOptions {
    /** How many chunks to fetch in parallel. Default 4 — high enough to halve
     *  wall-clock time on a 100-item lookup, low enough that the per-seller
     *  rate limit stays within burst on hot paths. */
    concurrency?: number;
}
declare function multigetItems(client: MeliClient, itemIds: string[], options?: MultigetOptions): Promise<Item[]>;
declare function createItem(client: MeliClient, payload: ItemCreateRequest): Promise<Item>;
declare function updateItem(client: MeliClient, itemId: string, payload: ItemUpdateRequest): Promise<Item>;
declare function pauseItem(client: MeliClient, itemId: string): Promise<Item>;
declare function closeItem(client: MeliClient, itemId: string): Promise<Item>;
declare function relistItem(client: MeliClient, itemId: string, args?: {
    listing_type_id?: Item["listing_type_id"];
    quantity?: number;
    price?: number;
}): Promise<Item>;
declare const SellerItemsSearchResponse: z.ZodObject<{
    paging: z.ZodObject<{
        total: z.ZodNumber;
        offset: z.ZodOptional<z.ZodNumber>;
        limit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    results: z.ZodArray<z.ZodString>;
    scroll_id: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type SellerItemsSearchResponse = z.infer<typeof SellerItemsSearchResponse>;
interface SearchSellerItemsOptions {
    /** Status filter. */
    status?: "active" | "paused" | "closed" | "all";
    /** ISO date filter — items updated after this. */
    updatedAfter?: string;
    /** Sort. */
    sort?: "last_updated_desc" | "last_updated_asc";
    /** Page size. Default 50. */
    limit?: number;
    /** Continuation token from the previous call. */
    scrollId?: string;
}
declare function searchSellerItems(client: MeliClient, sellerId: number, options?: SearchSellerItemsOptions): Promise<SellerItemsSearchResponse>;
/**
 * Iterate ALL items for a seller, transparently paging via `scroll_id`.
 * Yields one item id at a time; the caller decides batching.
 */
declare function iterateSellerItems(client: MeliClient, sellerId: number, options?: Omit<SearchSellerItemsOptions, "scrollId">): AsyncGenerator<string, void, void>;
declare const ItemDescription: z.ZodObject<{
    text: z.ZodOptional<z.ZodString>;
    plain_text: z.ZodOptional<z.ZodString>;
    last_updated: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ItemDescription = z.infer<typeof ItemDescription>;
declare function getItemDescription(client: MeliClient, itemId: string): Promise<ItemDescription>;
declare function updateItemDescription(client: MeliClient, itemId: string, description: {
    plain_text: string;
}): Promise<ItemDescription>;

interface PredictCategoryInput {
    title: string;
    /** Optional price (currency-aware predictions). */
    price?: number | undefined;
    /** Optional listing condition. */
    condition?: "new" | "used" | undefined;
}
declare function predictCategory(client: MeliClient, site: SiteId, input: PredictCategoryInput): Promise<CategoryPrediction>;
declare function discoverDomain(client: MeliClient, site: SiteId, query: string, options?: {
    limit?: number;
}): Promise<DomainDiscoveryResult[]>;
declare function getDomainTechnicalSpecs(client: MeliClient, domainId: string): Promise<TechnicalSpecResponse>;
/**
 * Convenience: classify required attribute ids for a domain. Useful for
 * an agent flow that wants to ensure mandatory fields are filled BEFORE
 * trying to publish.
 */
declare function getRequiredAttributeIds(client: MeliClient, domainId: string): Promise<string[]>;
declare function getCategory(client: MeliClient, categoryId: string): Promise<CategoryMetadata>;
declare function listSiteCategories(client: MeliClient, site: SiteId): Promise<Array<{
    id: string;
    name: string;
}>>;
interface CategorizeAndPlanResult {
    prediction: CategoryPrediction;
    /** All required attribute ids for the predicted domain. */
    requiredAttributeIds: string[];
    /** Full technical specs (use to render the form / fill via LLM). */
    technicalSpecs: TechnicalSpecResponse;
}
/**
 * One-shot: take a listing title (+ optional price/condition), predict the
 * category, fetch required attributes, and return everything needed for an
 * agent to publish a complete listing.
 *
 * This is the core of the "agent publishes a listing in 30 seconds" demo.
 */
declare function categorizeAndPlan(client: MeliClient, site: SiteId, input: PredictCategoryInput): Promise<CategorizeAndPlanResult>;

interface ListQuestionsOptions {
    status?: "ANSWERED" | "UNANSWERED" | "CLOSED_UNANSWERED";
    itemId?: string;
    /** Default 50. Max 100 per the docs. */
    limit?: number;
    offset?: number;
    /** Sort, default `date_created.desc`. */
    sort?: "date_created.desc" | "date_created.asc";
}
declare function listQuestions(client: MeliClient, sellerId: number, options?: ListQuestionsOptions): Promise<QuestionsSearchResponse>;
declare function getQuestion(client: MeliClient, questionId: number): Promise<Question>;
declare const AnswerResponse: z.ZodObject<{
    id: z.ZodNumber;
    text: z.ZodString;
    status: z.ZodOptional<z.ZodString>;
    date_created: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare function answerQuestion(client: MeliClient, request: AnswerRequest): Promise<z.infer<typeof AnswerResponse>>;
declare function blacklistAsker(client: MeliClient, sellerId: number, askerUserId: number): Promise<void>;
declare function unblockAsker(client: MeliClient, sellerId: number, askerUserId: number): Promise<void>;
interface ClassifySpamInput {
    question: Question;
    /** Fetched separately when needed (asker history). */
    askerProfile?: {
        answered_questions?: number;
        account_age_days?: number;
    };
    /** Set of question texts (or hashes) seen across this seller's catalog. */
    recentQuestionsByThisAsker?: string[];
}
declare function extractSpamFeatures(input: ClassifySpamInput): QuestionSpamFeatures;
/**
 * Score 0..1 — higher is more likely spam. Uses a transparent heuristic so
 * agents can explain their decision.
 */
declare function scoreSpam(features: QuestionSpamFeatures): number;
type SpamLabel = "spam" | "borderline" | "ham";
declare function classifySpam(input: ClassifySpamInput): {
    label: SpamLabel;
    score: number;
    features: QuestionSpamFeatures;
};

interface SearchOrdersOptions {
    /** Filter by order status. */
    status?: "paid" | "confirmed" | "payment_in_process" | "cancelled" | "invalid";
    /** Date filter: ISO 8601. */
    dateCreatedFrom?: string;
    dateCreatedTo?: string;
    dateLastUpdatedFrom?: string;
    /** Sort. Default `date_desc`. */
    sort?: "date_desc" | "date_asc";
    limit?: number;
    offset?: number;
    /** Tag filter (e.g. `paid`, `not_delivered`). */
    tags?: string[];
}
declare function searchOrders(client: MeliClient, sellerId: number, options?: SearchOrdersOptions): Promise<OrdersSearchResponse>;
declare function getOrder(client: MeliClient, orderId: number): Promise<Order>;
declare const OrderBillingInfo: z.ZodObject<{
    buyer: z.ZodObject<{
        billing_info: z.ZodOptional<z.ZodObject<{
            doc_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            doc_number: z.ZodOptional<z.ZodNullable<z.ZodString>>;
        }, z.core.$strip>>;
    }, z.core.$strip>;
}, z.core.$strip>;
type OrderBillingInfo = z.infer<typeof OrderBillingInfo>;
declare function getOrderBillingInfo(client: MeliClient, orderId: number): Promise<OrderBillingInfo>;
declare function getPack(client: MeliClient, packId: number): Promise<Pack>;
/**
 * Given an array of orders, group cart-orders by `pack_id` and return
 * (single-order, packs) so callers can iterate without double-counting.
 */
declare function partitionByPack(orders: Order[]): {
    singleOrders: Order[];
    packs: Map<number, Order[]>;
};

declare const ClaimsSearchResponse: z.ZodObject<{
    paging: z.ZodObject<{
        total: z.ZodNumber;
        offset: z.ZodOptional<z.ZodNumber>;
        limit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>;
    data: z.ZodArray<z.ZodObject<{
        id: z.ZodNumber;
        resource: z.ZodEnum<{
            order: "order";
            shipment: "shipment";
            payment: "payment";
        }>;
        resource_id: z.ZodNumber;
        status: z.ZodEnum<{
            closed: "closed";
            opened: "opened";
            expired: "expired";
            potential_claim: "potential_claim";
        }>;
        stage: z.ZodEnum<{
            cancelled: "cancelled";
            claim: "claim";
            dispute: "dispute";
            mediation: "mediation";
            resolved: "resolved";
        }>;
        parent_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        type: z.ZodOptional<z.ZodString>;
        reason_id: z.ZodOptional<z.ZodString>;
        reason: z.ZodOptional<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            detail: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>;
        fulfilled: z.ZodOptional<z.ZodBoolean>;
        quantity_type: z.ZodOptional<z.ZodString>;
        date_created: z.ZodString;
        last_updated: z.ZodOptional<z.ZodString>;
        resolution: z.ZodOptional<z.ZodNullable<z.ZodObject<{
            reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            decision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            benefited: z.ZodOptional<z.ZodArray<z.ZodString>>;
            date_created: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        players: z.ZodOptional<z.ZodArray<z.ZodObject<{
            role: z.ZodEnum<{
                complainant: "complainant";
                respondent: "respondent";
                mediator: "mediator";
            }>;
            type: z.ZodEnum<{
                buyer: "buyer";
                seller: "seller";
                ml: "ml";
            }>;
            user_id: z.ZodNumber;
            available_actions: z.ZodOptional<z.ZodArray<z.ZodString>>;
        }, z.core.$strip>>>;
        related_entities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
        site_id: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ClaimsSearchResponse = z.infer<typeof ClaimsSearchResponse>;
interface SearchClaimsOptions {
    stage?: "claim" | "dispute" | "mediation";
    status?: "opened" | "closed" | "expired";
    resource?: "order" | "shipment" | "payment";
    resourceId?: number;
    limit?: number;
    offset?: number;
}
declare function searchClaims(client: MeliClient, options?: SearchClaimsOptions): Promise<ClaimsSearchResponse>;
declare function getClaim(client: MeliClient, claimId: number): Promise<Claim>;
declare const ClaimEvidenceListResponse: z.ZodObject<{
    evidences: z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        type: z.ZodEnum<{
            PROOF_OF_SHIPMENT: "PROOF_OF_SHIPMENT";
            ITEM_DESCRIPTION_VS_RECEIVED: "ITEM_DESCRIPTION_VS_RECEIVED";
            VIDEO_OF_PRODUCT: "VIDEO_OF_PRODUCT";
            INVOICE: "INVOICE";
            MESSAGE_THREAD: "MESSAGE_THREAD";
            DELIVERY_PROOF: "DELIVERY_PROOF";
            RETURN_PROOF: "RETURN_PROOF";
            OTHER: "OTHER";
        }>;
        text: z.ZodOptional<z.ZodString>;
        attachment_url: z.ZodOptional<z.ZodString>;
        attachment_id: z.ZodOptional<z.ZodString>;
        date_created: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ClaimEvidenceListResponse = z.infer<typeof ClaimEvidenceListResponse>;
declare function listClaimEvidences(client: MeliClient, claimId: number): Promise<ClaimEvidenceListResponse>;
/**
 * Upload evidence to a claim. **Immutable per spec** — once submitted,
 * cannot be changed. The agent flow should compose all evidence in one
 * call; rejected submissions cannot be amended without opening a new
 * claim cycle.
 */
declare function uploadClaimEvidence(client: MeliClient, claimId: number, payload: EvidenceUploadRequest): Promise<ClaimEvidence>;
declare const ClaimMessagesResponse: z.ZodObject<{
    messages: z.ZodArray<z.ZodObject<{
        id: z.ZodOptional<z.ZodString>;
        date: z.ZodOptional<z.ZodString>;
        sender_role: z.ZodOptional<z.ZodEnum<{
            complainant: "complainant";
            respondent: "respondent";
            mediator: "mediator";
        }>>;
        sender_user_id: z.ZodOptional<z.ZodNumber>;
        message: z.ZodString;
        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
            url: z.ZodOptional<z.ZodString>;
            name: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type ClaimMessagesResponse = z.infer<typeof ClaimMessagesResponse>;
declare function listClaimMessages(client: MeliClient, claimId: number): Promise<ClaimMessagesResponse>;
declare function postClaimMessage(client: MeliClient, claimId: number, message: string): Promise<ClaimMessage>;
declare const ReturnReviewRequest: z.ZodObject<{
    decision: z.ZodEnum<{
        rejected: "rejected";
        accepted: "accepted";
    }>;
    reason: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ReturnReviewRequest = z.infer<typeof ReturnReviewRequest>;
declare const ReturnReviewResponse: z.ZodObject<{
    status: z.ZodString;
    decision: z.ZodOptional<z.ZodEnum<{
        rejected: "rejected";
        accepted: "accepted";
    }>>;
    date: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type ReturnReviewResponse = z.infer<typeof ReturnReviewResponse>;
declare function reviewReturn(client: MeliClient, returnId: number, payload: ReturnReviewRequest): Promise<ReturnReviewResponse>;
interface DefendClaimInput {
    claimId: number;
    evidences: EvidenceUploadRequest[];
    /** Optional message to post in the mediation thread alongside evidence. */
    message?: string;
}
interface DefendClaimResult {
    claim: Claim;
    uploadedEvidences: ClaimEvidence[];
    /** Evidences that failed to upload, in the same order they were submitted.
     *  When non-empty, the claim is partially defended — surface this to the
     *  human for manual review. */
    failedEvidences: {
        evidence: EvidenceUploadRequest;
        error: unknown;
    }[];
    messagePosted: ClaimMessage | null;
}
/**
 * The 2-day SLA defender flow. Loads claim metadata, uploads evidences
 * **sequentially** (NOT in parallel — see below), and optionally posts a
 * closing message.
 *
 * Why sequential. MELI's `/claims/{id}/evidences` endpoint has one-shot
 * semantics per evidence-type: if N requests land concurrently, MELI may
 * persist some, reject others as duplicates, or close the evidence window
 * mid-batch — leaving the claim half-defended with no way to amend.
 * Sequential uploads cap the blast radius: on failure, we stop and return
 * the partial state so the caller can decide whether to retry, escalate, or
 * proceed with the message.
 *
 * The cost is latency (~N × 200ms instead of ~200ms). For a typical 3-piece
 * defence under MELI's 2-day SLA, that's a non-issue.
 */
declare function defendClaim(client: MeliClient, input: DefendClaimInput): Promise<DefendClaimResult>;

declare function getSellerReputation(client: MeliClient, sellerId: number): Promise<SellerReputation>;
interface ReputationThresholds {
    /** Fire `warning` when claim rate >= warningClaimRate. Default 0.04. */
    warningClaimRate?: number;
    /** Fire `critical` when claim rate >= criticalClaimRate. Default 0.07. */
    criticalClaimRate?: number;
    /** Same for delayed handling time. Defaults 0.03 / 0.06. */
    warningDelayedHandlingRate?: number;
    criticalDelayedHandlingRate?: number;
    /** Cancellation rate. Defaults 0.02 / 0.05. */
    warningCancellationRate?: number;
    criticalCancellationRate?: number;
}
declare function evaluateReputationAlerts(reputation: SellerReputation, thresholds?: ReputationThresholds): ReputationAlert[];
interface MonitorReputationOptions {
    /** Poll interval in milliseconds. Default 5 minutes. */
    intervalMs?: number;
    thresholds?: ReputationThresholds;
    /** AbortSignal to stop the monitor. */
    signal?: AbortSignal;
    /** Callback fired when a transient (recoverable) error is swallowed. Use
     *  this to wire your telemetry/Sentry without breaking the polling loop. */
    onTransientError?: (error: unknown) => void;
}
/**
 * Yields `{ snapshot, alerts }` on every poll.
 *
 * Error handling:
 *   - **`MeliAuthError`** (revoked seller, banned app, OAuth refresh dead) →
 *     RE-THROWN. The connection is permanently broken; the caller needs to
 *     stop polling and surface this to the human.
 *   - **`MeliValidationError`** (programmer error — schema drift) →
 *     RE-THROWN. Bugs should fail loud, not silently.
 *   - **`MeliApiError`** that `isUnauthorized()` / `isForbidden()` (401/403 —
 *     revoked or expired token) → RE-THROWN. The endpoint is dead; polling it
 *     forever is useless.
 *   - **`MeliApiError`** with 5xx, **`MeliNetworkError`**, anything else →
 *     swallowed and reported via `onTransientError`. The loop keeps polling
 *     because transient failures are normal.
 */
declare function monitorReputation(client: MeliClient, sellerId: number, options?: MonitorReputationOptions): AsyncGenerator<{
    snapshot: SellerReputation | null;
    alerts: ReputationAlert[];
}, void, void>;

declare const PromotionCandidatesResponse: z.ZodObject<{
    results: z.ZodArray<z.ZodObject<{
        promotion_id: z.ZodString;
        promotion_type: z.ZodUnion<readonly [z.ZodEnum<{
            DEAL: "DEAL";
            DOD: "DOD";
            LIGHTNING: "LIGHTNING";
            SMART: "SMART";
            PRICE_DISCOUNT: "PRICE_DISCOUNT";
            SELLER_COUPON_CAMPAIGN: "SELLER_COUPON_CAMPAIGN";
            MARKETPLACE_CAMPAIGN: "MARKETPLACE_CAMPAIGN";
            PRICE_MATCHING: "PRICE_MATCHING";
            UNHEALTHY_STOCK: "UNHEALTHY_STOCK";
            VOLUME: "VOLUME";
            PRE_NEGOTIATED: "PRE_NEGOTIATED";
        }>, z.ZodString]>;
        start_date: z.ZodOptional<z.ZodString>;
        finish_date: z.ZodOptional<z.ZodString>;
        suggested_discount_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        max_discount_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        min_discount_percentage: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            original_price: z.ZodOptional<z.ZodNumber>;
            suggested_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            max_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            min_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
            currency_id: z.ZodOptional<z.ZodEnum<{
                ARS: "ARS";
                BRL: "BRL";
                MXN: "MXN";
                CLP: "CLP";
                COP: "COP";
                UYU: "UYU";
                PEN: "PEN";
                USD: "USD";
            }>>;
        }, z.core.$strip>>>;
    }, z.core.$strip>>;
    paging: z.ZodOptional<z.ZodObject<{
        total: z.ZodNumber;
        offset: z.ZodOptional<z.ZodNumber>;
        limit: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
}, z.core.$strip>;
type PromotionCandidatesResponse = z.infer<typeof PromotionCandidatesResponse>;
interface ListPromotionCandidatesOptions {
    promotionType?: "DEAL" | "DOD" | "LIGHTNING" | "SMART" | "PRICE_DISCOUNT" | "SELLER_COUPON_CAMPAIGN" | "MARKETPLACE_CAMPAIGN";
    limit?: number;
    offset?: number;
}
declare function listPromotionCandidates(client: MeliClient, sellerId: number, options?: ListPromotionCandidatesOptions): Promise<PromotionCandidatesResponse>;
declare function listActivePromotions(client: MeliClient, sellerId: number): Promise<PromotionCandidate[]>;
declare function optInPromotion(client: MeliClient, itemId: string, payload: PromotionOptInRequest): Promise<PromotionOptInResponse>;
interface MarginGuard {
    /** Item id → minimum margin we accept (decimal, e.g. 0.15 for 15%). */
    minimumMarginByItem?: Record<string, number>;
    /** Default minimum margin when item-specific isn't set. Default 0.15. */
    defaultMinimumMargin?: number;
    /** Item id → COGS in major units (used to compute margin from candidate's
     *  suggested_price). When absent, the candidate is SKIPPED (we'd rather
     *  miss revenue than auto-opt-in below cost). */
    cogsByItem: Record<string, number>;
}
interface AutoOptInResult {
    optedIn: PromotionOptInResponse[];
    skipped: Array<{
        itemId: string;
        promotionId: string;
        reason: "no_cogs" | "below_margin" | "no_suggested_price";
        detail: string;
    }>;
}
/**
 * Iterate candidates and opt-in to those that respect the configured
 * margin guard. Returns both opted-in items and skipped ones (with reason
 * codes for telemetry).
 */
declare function autoOptInPromotions(client: MeliClient, sellerId: number, guard: MarginGuard, options?: ListPromotionCandidatesOptions): Promise<AutoOptInResult>;

interface ParseWebhookOptions {
    /** Optional set of topics this app subscribes to. Throws on unknown. */
    expectedTopics?: ReadonlyArray<MeliWebhookTopic | string>;
    /** Optional application_id to assert. */
    expectedApplicationId?: number;
}
declare function parseWebhook(body: unknown, options?: ParseWebhookOptions): MeliWebhookEvent;
declare function extractResourceId(event: MeliWebhookEvent): string | null;
interface ReplayMissedFeedsOptions {
    appId: number;
    topic: MeliWebhookTopic | string;
    /** Optional from/to date filters (ISO 8601). */
    dateFrom?: string;
    dateTo?: string;
    /** Continuation cursor returned by previous call. */
    offset?: number;
    /** Page size, default 50. */
    limit?: number;
}
declare function replayMissedFeeds(client: MeliClient, options: ReplayMissedFeedsOptions): Promise<MissedFeed[]>;
/**
 * Iterate ALL missed feeds across topics. For each topic in `topics`,
 * pages through the feed and yields one event at a time.
 *
 * Use this when an app comes back online after >5 minutes of downtime —
 * it'll replay everything MELI tried to deliver while you were away,
 * within the 2-day retention window.
 */
declare function iterateAllMissedFeeds(client: MeliClient, appId: number, topics: ReadonlyArray<MeliWebhookTopic | string>, dateFrom?: string): AsyncGenerator<MissedFeed, void, void>;

export { Answer, AnswerRequest, type AutoOptInResult, type CategorizeAndPlanResult, CategoryId, CategoryMetadata, CategoryPrediction, Claim, ClaimEvidence, ClaimEvidenceListResponse, ClaimMessage, ClaimMessagesResponse, ClaimPlayer, ClaimReason, ClaimStage, ClaimStatus, ClaimsSearchResponse, type ClassifySpamInput, Currency, type DefendClaimInput, type DefendClaimResult, DomainDiscoveryResult, EvidenceType, EvidenceUploadRequest, type GetItemOptions, Item, ItemAttribute, ItemCreateRequest, ItemDescription, ItemStatus, ItemUpdateRequest, type ListPromotionCandidatesOptions, type ListQuestionsOptions, ListingType, type MarginGuard, MeliApiError, MeliAuthError, MeliClient, MeliError, type MeliErrorBody, MeliItemId, MeliNetworkError, MeliRateLimitError, MeliValidationError, MeliWebhookError, MeliWebhookEvent, MeliWebhookTopic, MissedFeed, MissedFeedsResponse, type MonitorReputationOptions, Order, OrderBillingInfo, OrderBuyer, OrderItem, OrderPayment, OrderStatus, OrdersSearchResponse, Pack, PagingResponse, type ParseWebhookOptions, Picture, PowerSellerStatus, type PredictCategoryInput, PromotionCandidate, PromotionCandidatesResponse, PromotionOptInRequest, PromotionOptInResponse, PromotionType, Question, QuestionSpamFeatures, QuestionStatus, QuestionsSearchResponse, type ReplayMissedFeedsOptions, ReputationAlert, ReputationAlertSeverity, ReputationLevel, ReputationMetric, ReputationMetrics, type ReputationThresholds, ReturnReviewRequest, ReturnReviewResponse, ScrollPagingResponse, type SearchClaimsOptions, type SearchOrdersOptions, type SearchSellerItemsOptions, SellerItemsSearchResponse, SellerReputation, SiteId, type SpamLabel, TechnicalSpecAttribute, TechnicalSpecResponse, answerQuestion, autoOptInPromotions, blacklistAsker, categorizeAndPlan, classifySpam, closeItem, createItem, defendClaim, discoverDomain, evaluateReputationAlerts, extractResourceId, extractSpamFeatures, getCategory, getClaim, getDomainTechnicalSpecs, getItem, getItemDescription, getOrder, getOrderBillingInfo, getPack, getQuestion, getRequiredAttributeIds, getSellerReputation, isMeliError, iterateAllMissedFeeds, iterateSellerItems, listActivePromotions, listClaimEvidences, listClaimMessages, listPromotionCandidates, listQuestions, listSiteCategories, monitorReputation, multigetItems, optInPromotion, parseWebhook, partitionByPack, pauseItem, postClaimMessage, predictCategory, relistItem, replayMissedFeeds, reviewReturn, scoreSpam, searchClaims, searchOrders, searchSellerItems, unblockAsker, updateItem, updateItemDescription, uploadClaimEvidence };