import { AddPricesDTO, Context, DAL, FindConfig, InferEntityType, InternalModuleDeclaration, MedusaContainer, ModuleJoinerConfig, ModulesSdkTypes, PricePreferenceDTO, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, UpsertPricePreferenceDTO, UpsertPriceSetDTO } from "@medusajs/framework/types";
import { ModulesSdkUtils, PriceListType, PricingRuleOperator } from "@medusajs/framework/utils";
import { Price, PriceList, PriceListRule, PricePreference, PriceRule, PriceSet } from "../models";
import { ServiceTypes } from "../types";
type InjectedDependencies = {
    baseRepository: DAL.RepositoryService;
    pricingRepository: PricingRepositoryService;
    priceSetService: ModulesSdkTypes.IMedusaInternalService<any>;
    priceRuleService: ModulesSdkTypes.IMedusaInternalService<any>;
    priceService: ModulesSdkTypes.IMedusaInternalService<any>;
    priceListService: ModulesSdkTypes.IMedusaInternalService<any>;
    pricePreferenceService: ModulesSdkTypes.IMedusaInternalService<any>;
    priceListRuleService: ModulesSdkTypes.IMedusaInternalService<any>;
};
declare const BaseClass: ModulesSdkUtils.MedusaServiceReturnType<{
    PriceSet: {
        dto: PricingTypes.PriceSetDTO;
    };
    Price: {
        dto: PricingTypes.PriceDTO;
    };
    PriceRule: {
        dto: PricingTypes.PriceRuleDTO;
        create: PricingTypes.CreatePriceRuleDTO;
        update: PricingTypes.UpdatePriceRuleDTO;
    };
    PriceList: {
        dto: PricingTypes.PriceListDTO;
    };
    PriceListRule: {
        dto: PricingTypes.PriceListRuleDTO;
    };
    PricePreference: {
        dto: any;
    };
}>;
export default class PricingModuleService extends BaseClass implements PricingTypes.IPricingModuleService {
    protected readonly moduleDeclaration: InternalModuleDeclaration;
    protected readonly container_: MedusaContainer;
    protected baseRepository_: DAL.RepositoryService;
    protected readonly pricingRepository_: PricingRepositoryService & {
        clearAvailableAttributes?: () => Promise<void>;
    };
    protected readonly priceSetService_: ModulesSdkTypes.IMedusaInternalService<InferEntityType<typeof PriceSet>>;
    protected readonly priceRuleService_: ModulesSdkTypes.IMedusaInternalService<InferEntityType<typeof PriceRule>>;
    protected readonly priceService_: ModulesSdkTypes.IMedusaInternalService<InferEntityType<typeof Price>>;
    protected readonly priceListService_: ModulesSdkTypes.IMedusaInternalService<InferEntityType<typeof PriceList>>;
    protected readonly priceListRuleService_: ModulesSdkTypes.IMedusaInternalService<InferEntityType<typeof PriceListRule>>;
    protected readonly pricePreferenceService_: ModulesSdkTypes.IMedusaInternalService<InferEntityType<typeof PricePreference>>;
    constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, pricePreferenceService, priceListService, priceListRuleService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
    __joinerConfig(): ModuleJoinerConfig;
    private setupCalculatedPriceConfig_;
    createPriceRules(...args: Parameters<PricingTypes.IPricingModuleService["createPriceRules"]>): Promise<PricingTypes.PriceRuleDTO | PricingTypes.PriceRuleDTO[]>;
    updatePriceRules(...args: Parameters<PricingTypes.IPricingModuleService["updatePriceRules"]>): Promise<PricingTypes.PriceRuleDTO | PricingTypes.PriceRuleDTO[]>;
    createPriceListRules(...args: any[]): Promise<PricingTypes.PriceListRuleDTO | PricingTypes.PriceListRuleDTO[]>;
    updatePriceListRules(...args: any[]): Promise<PricingTypes.PriceListRuleDTO | PricingTypes.PriceListRuleDTO[]>;
    retrievePriceSet(id: string, config?: FindConfig<PriceSetDTO> | undefined, sharedContext?: Context | undefined): Promise<PriceSetDTO>;
    listPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PriceSetDTO[]>;
    listAndCountPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PriceSetDTO[], number]>;
    listPriceRules(filters: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
    protected listPriceRules_(filters: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<InferEntityType<typeof PriceRule>[]>;
    listPricePreferences(filters: PricingTypes.FilterablePricePreferenceProps, config?: FindConfig<PricingTypes.PricePreferenceDTO>, sharedContext?: Context): Promise<PricingTypes.PricePreferenceDTO[]>;
    protected listPricePreferences_(filters: PricingTypes.FilterablePricePreferenceProps, config?: FindConfig<PricingTypes.PricePreferenceDTO>, sharedContext?: Context): Promise<InferEntityType<typeof PricePreference>[]>;
    calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
    createPriceSets(data: PricingTypes.CreatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
    createPriceSets(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
    upsertPriceSets(data: UpsertPriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
    upsertPriceSets(data: UpsertPriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
    protected upsertPriceSets_(data: UpsertPriceSetDTO | UpsertPriceSetDTO[], sharedContext?: Context): Promise<InferEntityType<typeof PriceSet>[]>;
    updatePriceSets(id: string, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
    updatePriceSets(selector: PricingTypes.FilterablePriceSetProps, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO[]>;
    protected updatePriceSets_(data: ServiceTypes.UpdatePriceSetInput[], sharedContext?: Context): Promise<InferEntityType<typeof PriceSet>[]>;
    private normalizeUpdateData;
    private normalizePrices;
    addPrices(data: AddPricesDTO, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
    addPrices(data: AddPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
    createPriceLists(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
    updatePriceLists(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
    updatePriceListPrices(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceDTO[]>;
    removePrices(ids: string[], sharedContext?: Context): Promise<void>;
    addPriceListPrices(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceDTO[]>;
    setPriceListRules(data: PricingTypes.SetPriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
    removePriceListRules(data: PricingTypes.RemovePriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
    createPricePreferences(data: PricingTypes.CreatePricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO>;
    createPricePreferences(data: PricingTypes.CreatePricePreferenceDTO[], sharedContext?: Context): Promise<PricePreferenceDTO[]>;
    upsertPricePreferences(data: UpsertPricePreferenceDTO[], sharedContext?: Context): Promise<PricePreferenceDTO[]>;
    upsertPricePreferences(data: UpsertPricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO>;
    protected upsertPricePreferences_(data: UpsertPricePreferenceDTO | UpsertPricePreferenceDTO[], sharedContext?: Context): Promise<InferEntityType<typeof PricePreference>[]>;
    updatePricePreferences(id: string, data: PricingTypes.UpdatePricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO>;
    updatePricePreferences(selector: PricingTypes.FilterablePricePreferenceProps, data: PricingTypes.UpdatePricePreferenceDTO, sharedContext?: Context): Promise<PricePreferenceDTO[]>;
    protected createPricePreferences_(data: PricingTypes.CreatePricePreferenceDTO[], sharedContext?: Context): Promise<{
        id: string;
        attribute: string;
        value: string | null;
        is_tax_inclusive: boolean;
        created_at: Date;
        updated_at: Date;
        deleted_at: Date | null;
    }[]>;
    protected updatePricePreferences_(data: PricingTypes.UpdatePricePreferenceDTO[], sharedContext?: Context): Promise<{
        id: string;
        attribute: string;
        value: string | null;
        is_tax_inclusive: boolean;
        created_at: Date;
        updated_at: Date;
        deleted_at: Date | null;
    }[]>;
    protected createPriceSets_(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<{
        id: string;
        prices: {
            id: string;
            title: string | null;
            currency_code: string;
            amount: number;
            min_quantity: number | null;
            max_quantity: number | null;
            rules_count: number | null;
            price_set: /*elided*/ any;
            price_rules: {
                id: string;
                attribute: string;
                value: string;
                operator: PricingRuleOperator;
                priority: number;
                price: /*elided*/ any;
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
                price_id: string;
            }[];
            price_list: {
                id: string;
                title: string;
                description: string;
                status: import("@medusajs/framework/utils").PriceListStatus;
                type: PriceListType;
                starts_at: Date | null;
                ends_at: Date | null;
                rules_count: number | null;
                prices: /*elided*/ any[];
                price_list_rules: {
                    id: string;
                    attribute: string;
                    value: NoInfer<Record<string, unknown>> | null;
                    price_list: /*elided*/ any;
                    created_at: Date;
                    updated_at: Date;
                    deleted_at: Date | null;
                    price_list_id: string;
                }[];
                metadata: NoInfer<Record<string, unknown>> | null;
                raw_rules_count: Record<string, unknown> | null;
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
            };
            raw_amount: Record<string, unknown>;
            raw_min_quantity: Record<string, unknown> | null;
            raw_max_quantity: Record<string, unknown> | null;
            raw_rules_count: Record<string, unknown> | null;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
            price_set_id: string;
            price_list_id: string | null;
        }[];
        created_at: Date;
        updated_at: Date;
        deleted_at: Date | null;
    }[]>;
    protected addPrices_(input: AddPricesDTO[], sharedContext?: Context): Promise<{
        id: string;
        title: string | null;
        currency_code: string;
        amount: number;
        min_quantity: number | null;
        max_quantity: number | null;
        rules_count: number | null;
        price_set: {
            id: string;
            prices: /*elided*/ any[];
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
        };
        price_rules: {
            id: string;
            attribute: string;
            value: string;
            operator: PricingRuleOperator;
            priority: number;
            price: /*elided*/ any;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
            price_id: string;
        }[];
        price_list: {
            id: string;
            title: string;
            description: string;
            status: import("@medusajs/framework/utils").PriceListStatus;
            type: PriceListType;
            starts_at: Date | null;
            ends_at: Date | null;
            rules_count: number | null;
            prices: /*elided*/ any[];
            price_list_rules: {
                id: string;
                attribute: string;
                value: NoInfer<Record<string, unknown>> | null;
                price_list: /*elided*/ any;
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
                price_list_id: string;
            }[];
            metadata: NoInfer<Record<string, unknown>> | null;
            raw_rules_count: Record<string, unknown> | null;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
        };
        raw_amount: Record<string, unknown>;
        raw_min_quantity: Record<string, unknown> | null;
        raw_max_quantity: Record<string, unknown> | null;
        raw_rules_count: Record<string, unknown> | null;
        created_at: Date;
        updated_at: Date;
        deleted_at: Date | null;
        price_set_id: string;
        price_list_id: string | null;
    }[]>;
    protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<{
        id: string;
        title: string;
        description: string;
        status: import("@medusajs/framework/utils").PriceListStatus;
        type: PriceListType;
        starts_at: Date | null;
        ends_at: Date | null;
        rules_count: number | null;
        prices: {
            id: string;
            title: string | null;
            currency_code: string;
            amount: number;
            min_quantity: number | null;
            max_quantity: number | null;
            rules_count: number | null;
            price_set: {
                id: string;
                prices: /*elided*/ any[];
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
            };
            price_rules: {
                id: string;
                attribute: string;
                value: string;
                operator: PricingRuleOperator;
                priority: number;
                price: /*elided*/ any;
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
                price_id: string;
            }[];
            price_list: /*elided*/ any;
            raw_amount: Record<string, unknown>;
            raw_min_quantity: Record<string, unknown> | null;
            raw_max_quantity: Record<string, unknown> | null;
            raw_rules_count: Record<string, unknown> | null;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
            price_set_id: string;
            price_list_id: string | null;
        }[];
        price_list_rules: {
            id: string;
            attribute: string;
            value: NoInfer<Record<string, unknown>> | null;
            price_list: /*elided*/ any;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
            price_list_id: string;
        }[];
        metadata: NoInfer<Record<string, unknown>> | null;
        raw_rules_count: Record<string, unknown> | null;
        created_at: Date;
        updated_at: Date;
        deleted_at: Date | null;
    }[]>;
    protected updatePriceLists_(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<{
        id: string;
        title: string;
        description: string;
        status: import("@medusajs/framework/utils").PriceListStatus;
        type: PriceListType;
        starts_at: Date | null;
        ends_at: Date | null;
        rules_count: number | null;
        prices: {
            id: string;
            title: string | null;
            currency_code: string;
            amount: number;
            min_quantity: number | null;
            max_quantity: number | null;
            rules_count: number | null;
            price_set: {
                id: string;
                prices: /*elided*/ any[];
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
            };
            price_rules: {
                id: string;
                attribute: string;
                value: string;
                operator: PricingRuleOperator;
                priority: number;
                price: /*elided*/ any;
                created_at: Date;
                updated_at: Date;
                deleted_at: Date | null;
                price_id: string;
            }[];
            price_list: /*elided*/ any;
            raw_amount: Record<string, unknown>;
            raw_min_quantity: Record<string, unknown> | null;
            raw_max_quantity: Record<string, unknown> | null;
            raw_rules_count: Record<string, unknown> | null;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
            price_set_id: string;
            price_list_id: string | null;
        }[];
        price_list_rules: {
            id: string;
            attribute: string;
            value: NoInfer<Record<string, unknown>> | null;
            price_list: /*elided*/ any;
            created_at: Date;
            updated_at: Date;
            deleted_at: Date | null;
            price_list_id: string;
        }[];
        metadata: NoInfer<Record<string, unknown>> | null;
        raw_rules_count: Record<string, unknown> | null;
        created_at: Date;
        updated_at: Date;
        deleted_at: Date | null;
    }[]>;
    protected updatePriceListPrices_(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<InferEntityType<typeof Price>[]>;
    protected removePrices_(ids: string[], sharedContext?: Context): Promise<void>;
    protected addPriceListPrices_(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<InferEntityType<typeof Price>[]>;
    protected setPriceListRules_(data: PricingTypes.SetPriceListRulesDTO[], sharedContext?: Context): Promise<InferEntityType<typeof PriceList>[]>;
    protected removePriceListRules_(data: PricingTypes.RemovePriceListRulesDTO[], sharedContext?: Context): Promise<InferEntityType<typeof PriceList>[]>;
    protected normalizePriceListDate(data: (ServiceTypes.UpdatePriceListDTO | ServiceTypes.CreatePriceListDTO | ServiceTypes.CreatePriceListDTO)[]): any[];
    protected normalizePriceSetConfig(config: FindConfig<PricingTypes.PriceSetDTO> | undefined): {
        select?: ((string & {}) | keyof PriceSetDTO)[] | undefined;
        skip?: number | null | undefined;
        take?: number | null | undefined;
        relations?: string[];
        order?: import("@medusajs/framework/types").FindConfigOrder;
        withDeleted?: boolean;
        filters?: Record<string, any>;
        options: Record<string, any>;
        __internal?: DAL.InternalQueryOptions;
    };
}
export {};
//# sourceMappingURL=pricing-module.d.ts.map