import type { FACET_CROSS_SELLING_MAP } from '../../utils/facets';
import { type CommercialAuthorizationResponse, type ICommercialAuthorizationByOrderId, type IProcessOrderAuthorization, type IUserOrderCancel, type QueryListUserOrdersArgs, type StoreMarketingData, type UserOrder, type UserOrderCancel, type UserOrderListResult } from '../../../..';
import type { Context, Options } from '../../index';
import type { Channel } from '../../utils/channel';
import type { ContractResponse } from './Contract';
import type { Address, AddressInput } from './types/Address';
import type { Brand } from './types/Brand';
import type { CategoryTree } from './types/CategoryTree';
import type { MasterDataResponse } from './types/Newsletter';
import type { OrderForm, OrderFormInputItem } from './types/OrderForm';
import type { PickupPoints, PickupPointsInput } from './types/PickupPoints';
import type { PortalPagetype } from './types/Portal';
import type { PortalProduct } from './types/Product';
import type { Region, RegionInput } from './types/Region';
import type { SalesChannel } from './types/SalesChannel';
import type { Session } from './types/Session';
import type { DeliveryMode, SelectedAddress } from './types/ShippingData';
import type { Simulation, SimulationArgs, SimulationOptions } from './types/Simulation';
import type { ScopesByUnit, UnitResponse } from './types/Unit';
import type { VtexIdResponse } from './types/VtexId';
type ValueOf<T> = T extends Record<string, infer K> ? K : never;
export declare const VtexCommerce: ({ account, environment, incrementAddress, subDomainPrefix }: Options, ctx: Context) => {
    catalog: {
        salesChannel: (sc: string) => Promise<SalesChannel>;
        brand: {
            list: () => Promise<Brand[]>;
        };
        category: {
            tree: (depth?: number) => Promise<CategoryTree[]>;
        };
        portal: {
            pagetype: (slug: string) => Promise<PortalPagetype>;
        };
        products: {
            crossselling: ({ type, productId, groupByProduct, }: {
                type: ValueOf<typeof FACET_CROSS_SELLING_MAP>;
                productId: string;
                groupByProduct?: boolean | undefined;
            }) => Promise<PortalProduct[]>;
        };
    };
    checkout: {
        simulation: (args: SimulationArgs, { salesChannel }?: SimulationOptions) => Promise<Simulation>;
        shippingData: ({ id, index, deliveryMode, selectedAddresses, }: {
            id: string;
            index: number;
            deliveryMode?: DeliveryMode | null | undefined;
            selectedAddresses: SelectedAddress[];
        }, setDeliveryWindow?: boolean) => Promise<OrderForm>;
        marketingData: ({ id, marketingData, }: {
            id: string;
            marketingData: StoreMarketingData;
        }) => Promise<OrderForm>;
        orderForm: ({ id, refreshOutdatedData, channel, }: {
            id?: string | undefined;
            refreshOutdatedData?: boolean | undefined;
            channel?: Required<Channel> | undefined;
        }) => Promise<OrderForm>;
        clearOrderFormMessages: ({ id }: {
            id: string;
        }) => Promise<any>;
        updateOrderFormItems: ({ id, orderItems, allowOutdatedData, salesChannel, shouldSplitItem, }: {
            id: string;
            orderItems: OrderFormInputItem[];
            allowOutdatedData?: "paymentData" | undefined;
            salesChannel?: string | undefined;
            shouldSplitItem?: boolean | null | undefined;
        }) => Promise<OrderForm>;
        setCustomData: ({ id, appId, key, value, }: {
            id: string;
            appId: string;
            key: string;
            value: string;
        }) => Promise<OrderForm>;
        region: ({ postalCode, geoCoordinates, country, salesChannel, }: RegionInput) => Promise<Region[]>;
        address: ({ postalCode, country, }: AddressInput) => Promise<Address>;
        cancelOrder: ({ orderId, customerEmail, reason, }: IUserOrderCancel) => Promise<UserOrderCancel> | undefined;
        pickupPoints: ({ geoCoordinates, }: PickupPointsInput) => Promise<PickupPoints>;
    };
    session: (search: string) => Promise<Session>;
    subscribeToNewsletter: (data: {
        name: string;
        email: string;
    }) => Promise<MasterDataResponse>;
    profile: {
        addresses: (userId: string) => Promise<Record<string, string>>;
    };
    oms: {
        userOrder: ({ orderId }: {
            orderId: string;
        }) => Promise<UserOrder>;
        listUserOrders: ({ page, status, dateInitial, dateFinal, text, clientEmail, perPage, pendingMyApproval, }: QueryListUserOrdersArgs) => Promise<UserOrderListResult>;
        getCommercialAuthorizationsByOrderId: ({ orderId, }: ICommercialAuthorizationByOrderId) => Promise<CommercialAuthorizationResponse>;
        processOrderAuthorization: ({ orderAuthorizationId, dimensionId, ruleId, approved, }: IProcessOrderAuthorization) => Promise<CommercialAuthorizationResponse>;
    };
    units: {
        getUnitByUserId: ({ userId, }: {
            userId: string;
        }) => Promise<UnitResponse>;
        getOrgUnitById: ({ orgUnitId, }: {
            orgUnitId: string;
        }) => Promise<UnitResponse>;
        getScopesByOrgUnit: ({ orgUnitId, }: {
            orgUnitId: string;
        }) => Promise<ScopesByUnit>;
    };
    licenseManager: {
        getUserById: ({ userId, }: {
            userId: string;
        }) => Promise<{
            id: string;
            name: string;
            email: string;
        }>;
        getUserByEmail: ({ email, }: {
            email: string;
        }) => Promise<{
            id: string;
            name: string;
            email: string;
        }>;
    };
    masterData: {
        getContractById: ({ contractId, }: {
            contractId: string;
        }) => Promise<ContractResponse>;
        getShopperById: ({ userId, }: {
            userId: string;
        }) => Promise<Array<{
            firstName: string;
            lastName: string;
            email: string;
            phone: string;
        }>>;
    };
    vtexid: {
        validate: () => Promise<VtexIdResponse>;
    };
};
export {};
//# sourceMappingURL=index.d.ts.map