export interface MpWfsItem42 {
    MPItem: MPItem[];
    MPItemFeedHeader: MPItemFeedHeader;
}
export interface MPItem {
    Orderable: Orderable;
    TradeItem: TradeItem;
    Visible: Visible;
}
export interface Orderable {
    batterySize?: string;
    batteryTechnologyType: ContainedBatteryType;
    brand: string;
    chemicalAerosolPesticide: MustShipAlone;
    electronicsIndicator: MustShipAlone;
    endDate?: Date;
    hasBatteries?: MustShipAlone;
    lithiumIonBatteries?: LithiumIonBatteries;
    lithiumMetalBatteries?: LithiumMetalBatteries;
    MustShipAlone?: MustShipAlone;
    netContent?: NetContent;
    numberOfHazardousComponents?: number;
    price: number;
    productIdentifiers: ProductIdentifiers;
    productName: string;
    safetyDataSheet?: string[];
    shipsInOriginalPackaging?: MustShipAlone;
    sku: string;
    SkuUpdate?: MustShipAlone;
    startDate?: Date;
    stateRestrictions: SaleRestriction[];
}
export declare enum MustShipAlone {
    No = "No",
    Yes = "Yes"
}
export declare enum ContainedBatteryType {
    Alkaline = "Alkaline",
    CarbonZinc = "Carbon Zinc",
    DoesNotContainABattery = "Does Not Contain a Battery",
    LeadAcid = "Lead Acid",
    LeadAcidNonSpillable = "Lead Acid (Non-Spillable)",
    LithiumIon = "Lithium Ion",
    LithiumPrimaryLithiumMetal = "Lithium Primary (Lithium Metal)",
    Magnesium = "Magnesium",
    Mercury = "Mercury",
    MultipleTypes = "Multiple Types",
    NickelCadmium = "Nickel Cadmium",
    NickelMetalHydride = "Nickel Metal Hydride",
    Other = "Other",
    Silver = "Silver",
    Thermal = "Thermal"
}
export interface LithiumIonBatteries {
    batteryFormFactor: BatteryFormFactor;
    batteryModel: string;
    batteryWattHour: number;
    batteryWeight: number;
    includedBatteryPackaging: IncludedBatteryPackaging;
    numberOfBatteries: number;
    numberOfBatteryCells: number;
}
export declare enum BatteryFormFactor {
    Battery = "Battery",
    ButtonCell = "Button Cell",
    Cell = "Cell"
}
export declare enum IncludedBatteryPackaging {
    ContainedIn = "Contained In",
    Loose = "Loose",
    PackedWith = "Packed With"
}
export interface LithiumMetalBatteries {
    batteryFormFactor: BatteryFormFactor;
    batteryModel: string;
    batteryWeight: number;
    includedBatteryPackaging: IncludedBatteryPackaging;
    lithiumMetalContentWeight: number;
    numberOfBatteries: number;
    numberOfBatteryCells: number;
}
export interface NetContent {
    productNetContentMeasure?: number;
    productNetContentUnit?: ProductNetContentUnitEnum;
}
export declare enum ProductNetContentUnitEnum {
    Case = "Case",
    Centiliter = "Centiliter",
    Centimeter = "Centimeter",
    CubicFoot = "Cubic Foot",
    Each = "Each",
    FluidOunces = "Fluid Ounces",
    Foot = "Foot",
    Gallon = "Gallon",
    Gram = "Gram",
    Inch = "Inch",
    Kilogram = "Kilogram",
    Liter = "Liter",
    Meter = "Meter",
    Milliliter = "Milliliter",
    Ounce = "Ounce",
    PalletUnitLoad = "Pallet/Unit Load",
    Pint = "Pint",
    Pound = "Pound",
    Quart = "Quart",
    QuartDry = "Quart Dry",
    SquareFoot = "Square Foot",
    Yard = "Yard"
}
export interface ProductIdentifiers {
    productId: string;
    productIdType: ProductIDType;
}
export declare enum ProductIDType {
    Ean = "EAN",
    Gtin = "GTIN",
    Isbn = "ISBN",
    Upc = "UPC"
}
export interface SaleRestriction {
    stateRestrictionsText: RestrictionType;
    states?: string;
    zipCodes?: string;
}
export declare enum RestrictionType {
    Commercial = "Commercial",
    IllegalForSale = "Illegal for Sale",
    None = "None"
}
export interface TradeItem {
    case?: Case;
    countryOfOriginAssembly: CountryOfOrigin[];
    each?: Each;
    innerPack?: InnerPack;
    orderableGTIN: string;
    pallet?: Pallet;
    sku: string;
}
export interface Case {
    caseDepth: number;
    caseGTIN: string;
    caseHeight: number;
    caseWeight: number;
    caseWidth: number;
    qtySellableItemsCase: number;
}
export declare enum CountryOfOrigin {
    ADAndorra = "AD - Andorra",
    AEUnitedArabEmirates = "AE - United Arab Emirates",
    AFAfghanistan = "AF - Afghanistan",
    AGAntiguaAndBarbuda = "AG - Antigua and Barbuda",
    AIAnguilla = "AI - Anguilla",
    ALAlbania = "AL - Albania",
    AMArmenia = "AM - Armenia",
    ANNetherlandsAntilles = "AN - Netherlands Antilles",
    AOAngola = "AO - Angola",
    AQAntarctica = "AQ - Antarctica",
    ARArgentina = "AR - Argentina",
    ASAmericanSamoa = "AS - American Samoa",
    ATAustria = "AT - Austria",
    AUAustralia = "AU - Australia",
    AWAruba = "AW - Aruba",
    AXAlandIslands = "AX - Aland Islands",
    AZAzerbaijan = "AZ - Azerbaijan",
    BABosniaAndHerzegovina = "BA - Bosnia and Herzegovina",
    BBBarbados = "BB - Barbados",
    BDBangladesh = "BD - Bangladesh",
    BEBelgium = "BE - Belgium",
    BFBurkinaFaso = "BF - Burkina Faso",
    BGBulgaria = "BG - Bulgaria",
    BHBahrain = "BH - Bahrain",
    BIBurundi = "BI - Burundi",
    BJBenin = "BJ - Benin",
    BMBermuda = "BM - Bermuda",
    BNBruneiDarussalam = "BN - Brunei Darussalam",
    BOBolivia = "BO - Bolivia",
    BRBrazil = "BR - Brazil",
    BSBahamas = "BS - Bahamas",
    BTBhutan = "BT - Bhutan",
    BVBouvetIsland = "BV - Bouvet Island",
    BWBotswana = "BW - Botswana",
    BYBelarus = "BY - Belarus",
    BZBelize = "BZ - Belize",
    CACanada = "CA - Canada",
    CCCocosKeelingIslands = "CC - Cocos (Keeling) Islands",
    CDRepublicOfCongo = "CD - Republic of Congo",
    CFCentralAfricanRepublic = "CF - Central African Republic",
    CGCongo = "CG - Congo",
    CHSwitzerland = "CH - Switzerland",
    CICoteDIvoire = "CI - Cote d Ivoire",
    CKCookIslands = "CK - Cook Islands",
    CLChile = "CL - Chile",
    CMCameroon = "CM - Cameroon",
    CNChina = "CN - China",
    COColombia = "CO - Colombia",
    CRCostaRica = "CR - Costa Rica",
    CSSerbiaAndMontenegro = "CS - Serbia and Montenegro",
    CUCuba = "CU - Cuba",
    CVCapeVerde = "CV - Cape Verde",
    CXChristmasIsland = "CX - Christmas Island",
    CYCyprus = "CY - Cyprus",
    CZCzechRepublic = "CZ - Czech Republic",
    DEGermany = "DE - Germany",
    DJDjibouti = "DJ - Djibouti",
    DKDenmark = "DK - Denmark",
    DMDominica = "DM - Dominica",
    DODominicanRepublic = "DO - Dominican Republic",
    DZAlgeria = "DZ - Algeria",
    ECEcuador = "EC - Ecuador",
    EEEstonia = "EE - Estonia",
    EGEgypt = "EG - Egypt",
    EHWesternSahara = "EH - Western Sahara",
    EREritrea = "ER - Eritrea",
    ESSpain = "ES - Spain",
    ETEthiopia = "ET - Ethiopia",
    FIFinland = "FI - Finland",
    FJFiji = "FJ - Fiji",
    FKFalklandIslandsMalvinas = "FK - Falkland Islands (Malvinas)",
    FMMicronesia = "FM - Micronesia",
    FOFaroeIslands = "FO - Faroe Islands",
    FRFrance = "FR - France",
    FXFranceMetropolitan = "FX - France, Metropolitan",
    GAGabon = "GA - Gabon",
    GBUnitedKingdom = "GB - United Kingdom",
    GDGrenada = "GD - Grenada",
    GEGeorgia = "GE - Georgia",
    GFFrenchGuiana = "GF - French Guiana",
    GHGhana = "GH - Ghana",
    GIGibraltar = "GI - Gibraltar",
    GLGreenland = "GL - Greenland",
    GMGambia = "GM - Gambia",
    GNGuinea = "GN - Guinea",
    GPGuadeloupe = "GP - Guadeloupe",
    GQEquatorialGuinea = "GQ - Equatorial Guinea",
    GRGreece = "GR - Greece",
    GSSouthGeorgiaSoSandwichIsl = "GS - South Georgia/So Sandwich Isl",
    GTGuatemala = "GT - Guatemala",
    GUGuam = "GU - Guam",
    GWGuineaBissau = "GW - Guinea-Bissau",
    GYGuyana = "GY - Guyana",
    HKHongKong = "HK - Hong Kong",
    HMHeardIslandMcDonaldIsl = "HM - Heard Island & McDonald Isl",
    HNHonduras = "HN - Honduras",
    HRCroatia = "HR - Croatia",
    HTHaiti = "HT - Haiti",
    HUHungary = "HU - Hungary",
    IDIndonesia = "ID - Indonesia",
    IEIreland = "IE - Ireland",
    ILIsrael = "IL - Israel",
    IMIsleOfMan = "IM - Isle of Man",
    INIndia = "IN - India",
    IOBritishIndianOceanTerritory = "IO - British Indian Ocean Territory",
    IQIraq = "IQ - Iraq",
    IRIran = "IR - Iran",
    ISIceland = "IS - Iceland",
    ITItaly = "IT - Italy",
    JEJersey = "JE - Jersey",
    JMJamaica = "JM - Jamaica",
    JOJordan = "JO - Jordan",
    JPJapan = "JP - Japan",
    KEKenya = "KE - Kenya",
    KGKyrgyzstan = "KG - Kyrgyzstan",
    KHCambodia = "KH - Cambodia",
    KIKiribati = "KI - Kiribati",
    KMComoros = "KM - Comoros",
    KNSaintKittsAndNevis = "KN - Saint Kitts And Nevis",
    KPKoreaNorth = "KP - Korea, North",
    KRKoreaSouth = "KR - Korea, South",
    KWKuwait = "KW - Kuwait",
    KYCaymanIslands = "KY - Cayman Islands",
    KZKazakhstan = "KZ - Kazakhstan",
    LALaoPeopleSDemocraticRepublic = "LA - Lao People's Democratic Republic",
    LBLebanon = "LB - Lebanon",
    LCSaintLucia = "LC - Saint Lucia",
    LILiechtenstein = "LI - Liechtenstein",
    LKSriLanka = "LK - Sri Lanka",
    LRLiberia = "LR - Liberia",
    LSLesotho = "LS - Lesotho",
    LTLithuania = "LT - Lithuania",
    LULuxembourg = "LU - Luxembourg",
    LVLatvia = "LV - Latvia",
    LYLibyanArabJamahiriya = "LY - Libyan Arab Jamahiriya",
    MAMorocco = "MA - Morocco",
    MCMonaco = "MC - Monaco",
    MDRepublicOfMoldova = "MD - Republic of Moldova",
    MGMadagascar = "MG - Madagascar",
    MHMarshallIslands = "MH - Marshall Islands",
    MKMacedonia = "MK - Macedonia",
    MLMali = "ML - Mali",
    MMMyanmar = "MM - Myanmar",
    MNMongolia = "MN - Mongolia",
    MOMacaoSpecialAdministrativeRegionOfThePeopleSRepublicOfChina = "MO - Macao Special Administrative Region of the People's Republic of China",
    MPNorthernMarianaIslands = "MP - Northern Mariana Islands",
    MQMartinique = "MQ - Martinique",
    MRMauritania = "MR - Mauritania",
    MSMontserrat = "MS - Montserrat",
    MTMalta = "MT - Malta",
    MUMauritius = "MU - Mauritius",
    MVMaldives = "MV - Maldives",
    MWMalawi = "MW - Malawi",
    MXMexico = "MX - Mexico",
    MYMalaysia = "MY - Malaysia",
    MZMozambique = "MZ - Mozambique",
    NANamibia = "NA - Namibia",
    NCNewCaledonia = "NC - New Caledonia",
    NENiger = "NE - Niger",
    NFNorfolkIsland = "NF - Norfolk Island",
    NGNigeria = "NG - Nigeria",
    NINicaragua = "NI - Nicaragua",
    NLNetherlands = "NL - Netherlands",
    NONorway = "NO - Norway",
    NPNepal = "NP - Nepal",
    NRNauru = "NR - Nauru",
    NUNiue = "NU - Niue",
    NZNewZealand = "NZ - New Zealand",
    OMOman = "OM - Oman",
    PAPanama = "PA - Panama",
    PEPeru = "PE - Peru",
    PFFrenchPolynesia = "PF - French Polynesia",
    PGPapuaNewGuinea = "PG - Papua New Guinea",
    PHPhilippines = "PH - Philippines",
    PKPakistan = "PK - Pakistan",
    PLPoland = "PL - Poland",
    PMSaintPierreAndMiquelon = "PM - Saint Pierre And Miquelon",
    PNPitcairn = "PN - Pitcairn",
    PRPuertoRico = "PR - Puerto Rico",
    PSStateOfPalestine = "PS - State of Palestine",
    PTPortugal = "PT - Portugal",
    PWPalau = "PW - Palau",
    PYParaguay = "PY - Paraguay",
    QAQatar = "QA - Qatar",
    REReunion = "RE - Reunion",
    RORomania = "RO - Romania",
    RURussianFederation = "RU - Russian Federation",
    RWRwanda = "RW - Rwanda",
    SASaudiArabia = "SA - Saudi Arabia",
    SBSolomonIslands = "SB - Solomon Islands",
    SCSeychelles = "SC - Seychelles",
    SDSudan = "SD - Sudan",
    SESweden = "SE - Sweden",
    SGSingapore = "SG - Singapore",
    SHSaintHelena = "SH - Saint Helena",
    SISlovenia = "SI - Slovenia",
    SJSvalbardAndJanMayen = "SJ - Svalbard and Jan Mayen",
    SKSlovakia = "SK - Slovakia",
    SLSierraLeone = "SL - Sierra Leone",
    SMSANMarino = "SM - San Marino",
    SNSenegal = "SN - Senegal",
    SOSomalia = "SO - Somalia",
    SRSuriname = "SR - Suriname",
    STSaoTomeAndPrincipe = "ST - Sao Tome and Principe",
    SVElSalvador = "SV - El Salvador",
    SYSyrianArabRepublic = "SY - Syrian Arab Republic",
    SZSwaziland = "SZ - Swaziland",
    TCTurksAndCaicosIslands = "TC - Turks and Caicos Islands",
    TDChad = "TD - Chad",
    TFFrenchSouthernTerritories = "TF - French Southern Territories",
    TGTogo = "TG - Togo",
    THThailand = "TH - Thailand",
    TJTajikistan = "TJ - Tajikistan",
    TKTokelau = "TK - Tokelau",
    TLTimorLeste = "TL - Timor-Leste",
    TMTurkmenistan = "TM - Turkmenistan",
    TNTunisia = "TN - Tunisia",
    TOTonga = "TO - Tonga",
    TPEastTimor = "TP - East Timor",
    TRTurkey = "TR - Turkey",
    TTTrinidadAndTobago = "TT - Trinidad and Tobago",
    TVTuvalu = "TV - Tuvalu",
    TWTaiwan = "TW - Taiwan",
    TZTanzania = "TZ - Tanzania",
    UAUkraine = "UA - Ukraine",
    UGUganda = "UG - Uganda",
    UMUSMinorOutlyingIslands = "UM - US Minor Outlying Islands",
    USUnitedStates = "US - United States",
    UYUruguay = "UY - Uruguay",
    UZUzbekistan = "UZ - Uzbekistan",
    VAHolySee = "VA - Holy See",
    VCSaintVincentTheGrenadines = "VC - Saint Vincent & the Grenadines",
    VEVenezuela = "VE - Venezuela",
    VGVirginIslandsBritish = "VG - Virgin Islands (British)",
    VIVirginIslandsUS = "VI - Virgin Islands (U.S.)",
    VNVietNam = "VN - Viet Nam",
    VUVanuatu = "VU - Vanuatu",
    WFWallisAndFutunaIslands = "WF - Wallis and Futuna Islands",
    WSSamoa = "WS - Samoa",
    YEYemen = "YE - Yemen",
    YTMayotte = "YT - Mayotte",
    YUYugoslavia = "YU - Yugoslavia",
    ZASouthAfrica = "ZA - South Africa",
    ZMZambia = "ZM - Zambia",
    ZRZaire = "ZR - Zaire",
    ZWZimbabwe = "ZW - Zimbabwe"
}
export interface Each {
    eachDepth: number;
    eachGTIN: string;
    eachHeight: number;
    eachWeight: number;
    eachWidth: number;
}
export interface InnerPack {
    innerPackDepth: number;
    innerPackGTIN: string;
    innerPackHeight: number;
    innerPackWeight: number;
    innerPackWidth: number;
    qtySellableItemsInnerPack: number;
}
export interface Pallet {
    palletDepth: number;
    palletGTIN: string;
    palletHeight: number;
    palletWeight: number;
    palletWidth: number;
    qtySellableItemsPallet: number;
}
export interface Visible {
    'Animal Accessories'?: AnimalAccessories;
    'Animal Food'?: AnimalFood;
    'Animal Health & Grooming'?: AnimalHealthGrooming;
    'Animal Other'?: AnimalOther;
    'Art & Craft'?: ArtCraft;
    'Baby Clothing'?: BabyClothing;
    'Baby Diapering, Care, & Other'?: BabyDiaperingCareOther;
    'Baby Food'?: BabyFood;
    'Baby Furniture'?: BabyFurniture;
    'Baby Toys'?: BabyToys;
    'Baby Transport'?: BabyTransport;
    'Beauty, Personal Care, & Hygiene'?: BeautyPersonalCareHygiene;
    Bedding?: Bedding;
    'Building Supply'?: BuildingSupply;
    'Cameras & Lenses'?: CamerasLenses;
    'Carriers & Accessories'?: CarriersAccessories;
    'Cases & Bags'?: CasesBags;
    'Cell Phones'?: CellPhones;
    'Ceremonial Clothing & Accessories'?: CeremonialClothingAccessories;
    Clothing?: Clothing;
    'Computer Components'?: ComputerComponents;
    Computers?: Computers;
    Costumes?: Costumes;
    Cycling?: Cycling;
    'Decorations & Favors'?: DecorationsFavors;
    Electrical?: Electrical;
    'Electronics Accessories'?: ElectronicsAccessories;
    'Electronics Cables'?: ElectronicsCables;
    'Electronics Other'?: ElectronicsOther;
    'Food & Beverage'?: FoodBeverage;
    Footwear?: Footwear;
    'Fuels & Lubricants'?: FuelsLubricants;
    Funeral?: Funeral;
    Furniture?: Furniture;
    'Garden & Patio'?: GardenPatio;
    'Gift Supply & Awards'?: GiftSupplyAwards;
    'Grills & Outdoor Cooking'?: GrillsOutdoorCooking;
    Hardware?: Hardware;
    'Health & Beauty Electronics'?: HealthBeautyElectronics;
    'Home Decor, Kitchen, & Other'?: HomeDecorKitchenOther;
    'Household Cleaning Products & Supplies'?: HouseholdCleaningProductsSupplies;
    'Instrument Accessories'?: InstrumentAccessories;
    Jewelry?: Jewelry;
    'Land Vehicles'?: LandVehicles;
    'Large Appliances'?: LargeAppliances;
    'Medical Aids & Equipment'?: MedicalAidsEquipment;
    'Medicine & Supplements'?: MedicineSupplements;
    Movies?: Movies;
    Music?: Music;
    'Music Cases & Bags'?: MusicCasesBags;
    'Musical Instruments'?: MusicalInstruments;
    Office?: Office;
    Optical?: Optical;
    Optics?: Optics;
    Other?: Other;
    'Photo Accessories'?: PhotoAccessories;
    'Plumbing & HVAC'?: PlumbingHVAC;
    'Printers, Scanners, & Imaging'?: PrintersScannersImaging;
    'Safety & Emergency'?: SafetyEmergency;
    Software?: Software;
    'Sound & Recording'?: SoundRecording;
    'Sport & Recreation Other'?: SportRecreationOther;
    Storage?: Storage;
    Tools?: Tools;
    'Tools & Hardware Other'?: ToolsHardwareOther;
    Toys?: Toys;
    'TVs & Video Displays'?: TVsVideoDisplays;
    'Vehicle Other'?: VehicleOther;
    'Vehicle Parts & Accessories'?: VehiclePartsAccessories;
    'Video Games'?: VideoGames;
    'Video Projectors'?: VideoProjectors;
    Watches?: Watches;
    Watercraft?: Watercraft;
    'Wheels & Wheel Components'?: WheelsWheelComponents;
}
export interface AnimalAccessories {
    additionalProductAttributes?: AnimalAccessoriesAdditionalProductAttribute[];
    animalBreed?: string;
    animalLifestage?: string;
    animalType?: string;
    assembledProductHeight?: AnimalAccessoriesAssembledProductHeight;
    assembledProductLength?: AnimalAccessoriesAssembledProductLength;
    assembledProductWeight?: AnimalAccessoriesAssembledProductWeight;
    assembledProductWidth?: AnimalAccessoriesAssembledProductWidth;
    batteriesRequired?: MustShipAlone;
    capacity?: string;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: AnimalAccessoriesFabricContent[];
    features?: string[];
    globalBrandLicense?: string[];
    instructions?: string;
    isFoldable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReflective?: MustShipAlone;
    isRetractable?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumTemperature?: AnimalAccessoriesMaximumTemperature;
    maximumWeight?: AnimalAccessoriesMaximumWeight;
    minimumTemperature?: AnimalAccessoriesMinimumTemperature;
    minimumWeight?: AnimalAccessoriesMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    numberOfSteps?: number;
    pattern?: string[];
    petSize?: string;
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: AnimalAccessoriesSwatchImage[];
    variantAttributeNames?: AnimalAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface AnimalAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface AnimalAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum AssembledProductHeightUnit {
    Ft = "ft",
    In = "in"
}
export interface AnimalAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export declare enum AssembledProductWeightUnit {
    G = "g",
    Kg = "kg",
    LB = "lb",
    Oz = "oz"
}
export interface AnimalAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum ColorCategory {
    Beige = "Beige",
    Black = "Black",
    Blue = "Blue",
    Bronze = "Bronze",
    Brown = "Brown",
    Clear = "Clear",
    Gold = "Gold",
    Gray = "Gray",
    Green = "Green",
    MultiColor = "Multi-color",
    OffWhite = "Off-White",
    Orange = "Orange",
    Pink = "Pink",
    Purple = "Purple",
    Red = "Red",
    Silver = "Silver",
    White = "White",
    Yellow = "Yellow"
}
export declare enum CountryOfOriginTextiles {
    Imported = "Imported",
    USAAndImported = "USA and Imported",
    USAOrImported = "USA or Imported",
    Usa = "USA"
}
export interface AnimalAccessoriesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface AnimalAccessoriesMaximumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export declare enum MaximumTemperatureUnit {
    ºC = "\u00BAC",
    ºF = "\u00BAF",
    ºK = "\u00BAK"
}
export interface AnimalAccessoriesMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export declare enum PurpleUnit {
    G = "g",
    Kg = "kg",
    LB = "lb",
    Mg = "mg",
    Oz = "oz"
}
export interface AnimalAccessoriesMinimumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export interface AnimalAccessoriesMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: AnimalAccessoriesVariantAttributeName;
}
export declare enum AnimalAccessoriesVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Capacity = "capacity",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface AnimalFood {
    additionalProductAttributes?: AnimalFoodAdditionalProductAttribute[];
    animalBreed?: string;
    animalHealthConcern?: string[];
    animalLifestage?: string;
    animalType?: string;
    assembledProductHeight?: AnimalFoodAssembledProductHeight;
    assembledProductLength?: AnimalFoodAssembledProductLength;
    assembledProductWeight?: AnimalFoodAssembledProductWeight;
    assembledProductWidth?: AnimalFoodAssembledProductWidth;
    count?: string;
    countPerPack?: number;
    features?: string[];
    feedingInstructions?: string;
    flavor?: string;
    globalBrandLicense?: string[];
    ingredients?: string;
    instructions?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: AnimalFoodLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    maximumWeight?: AnimalFoodMaximumWeight;
    minimumWeight?: AnimalFoodMinimumWeight;
    msrp?: number;
    petFoodForm?: string;
    petSize?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shelfLife?: AnimalFoodShelfLife;
    shortDescription: string;
    size?: string;
    swatchImages?: AnimalFoodSwatchImage[];
    variantAttributeNames?: AnimalFoodVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface AnimalFoodAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface AnimalFoodAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalFoodAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalFoodAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalFoodAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalFoodLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export declare enum LabelImageContains {
    DrugFacts = "Drug Facts",
    IngredientList = "Ingredient List",
    NoLabel = "No Label",
    NutritionFacts = "Nutrition Facts",
    SupplementFacts = "Supplement Facts"
}
export interface AnimalFoodMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface AnimalFoodMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalFoodShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export declare enum ShelfLifeUnit {
    Days = "days"
}
export interface AnimalFoodSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: AnimalFoodVariantAttributeName;
}
export declare enum AnimalFoodVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Count = "count",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    Size = "size"
}
export interface AnimalHealthGrooming {
    activeIngredients?: AnimalHealthGroomingActiveIngredient[];
    additionalProductAttributes?: AnimalHealthGroomingAdditionalProductAttribute[];
    animalBreed?: string;
    animalHealthConcern?: string[];
    animalLifestage?: string;
    animalType?: string;
    assembledProductHeight?: AnimalHealthGroomingAssembledProductHeight;
    assembledProductLength?: AnimalHealthGroomingAssembledProductLength;
    assembledProductWeight?: AnimalHealthGroomingAssembledProductWeight;
    assembledProductWidth?: AnimalHealthGroomingAssembledProductWidth;
    color?: string[];
    count?: string;
    countPerPack?: number;
    dosage?: string;
    drugActiveInactiveIngredientsImage?: string;
    drugDosageInstructionsImage?: string;
    features?: string[];
    flavor?: string;
    form?: string;
    globalBrandLicense?: string[];
    hairLength?: string[];
    inactiveIngredients?: string[];
    ingredients?: string;
    instructions?: string;
    isDisposable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRetractable?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: AnimalHealthGroomingLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumWeight?: AnimalHealthGroomingMaximumWeight;
    minimumWeight?: AnimalHealthGroomingMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    petSize?: string;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    scent?: string;
    shelfLife?: AnimalHealthGroomingShelfLife;
    shortDescription: string;
    size?: string;
    stopUseIndications?: string[];
    swatchImages?: AnimalHealthGroomingSwatchImage[];
    variantAttributeNames?: AnimalHealthGroomingVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface AnimalHealthGroomingActiveIngredient {
    activeIngredientName?: string;
    activeIngredientPercentage?: number;
}
export interface AnimalHealthGroomingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface AnimalHealthGroomingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalHealthGroomingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalHealthGroomingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalHealthGroomingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalHealthGroomingLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export interface AnimalHealthGroomingMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface AnimalHealthGroomingMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalHealthGroomingShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface AnimalHealthGroomingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: AnimalHealthGroomingVariantAttributeName;
}
export declare enum AnimalHealthGroomingVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Scent = "scent",
    Size = "size"
}
export interface AnimalOther {
    additionalProductAttributes?: AnimalOtherAdditionalProductAttribute[];
    animalBreed?: string;
    animalLifestage?: string;
    animalType?: string;
    assembledProductHeight?: AnimalOtherAssembledProductHeight;
    assembledProductLength?: AnimalOtherAssembledProductLength;
    assembledProductWeight?: AnimalOtherAssembledProductWeight;
    assembledProductWidth?: AnimalOtherAssembledProductWidth;
    athlete?: string[];
    autographedBy?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: AnimalOtherFabricContent[];
    globalBrandLicense?: string[];
    inflexKitComponent?: MustShipAlone;
    instructions?: string;
    isFoldable?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumWeight?: AnimalOtherMaximumWeight;
    minimumWeight?: AnimalOtherMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    petSize?: string;
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: AnimalOtherSwatchImage[];
    variantAttributeNames?: AnimalOtherVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface AnimalOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface AnimalOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AnimalOtherFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface AnimalOtherMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface AnimalOtherMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface AnimalOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: AnimalOtherVariantAttributeName;
}
export declare enum AnimalOtherVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface ArtCraft {
    additionalProductAttributes?: ArtCraftAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    artPaintType?: string;
    assembledProductHeight?: ArtCraftAssembledProductHeight;
    assembledProductLength?: ArtCraftAssembledProductLength;
    assembledProductWeight?: ArtCraftAssembledProductWeight;
    assembledProductWidth?: ArtCraftAssembledProductWidth;
    boltLengthYardage?: BoltLengthYardage;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    diameter?: ArtCraftDiameter;
    fabricCareInstructions?: string[];
    fabricContent?: ArtCraftFabricContent[];
    fabricPurchaseForm?: FabricPurchaseForm;
    features?: string[];
    finish?: string;
    gender?: ArtCraftGender;
    globalBrandLicense?: string[];
    inflexKitComponent?: MustShipAlone;
    ingredients?: string;
    isBulk?: MustShipAlone;
    isDisposable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRecyclable?: MustShipAlone;
    isRefillable?: MustShipAlone;
    isSelfAdhesive?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: ArtCraftMaximumRecommendedAge;
    maximumTemperature?: ArtCraftMaximumTemperature;
    metal?: MetalType;
    minimumRecommendedAge?: ArtCraftMinimumRecommendedAge;
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    plating?: string;
    powerType?: string;
    precutFabricSpecialtySize?: PrecutFabricSpecialtySize;
    productLine?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedSurfaces?: string[];
    recommendedUses?: string[];
    scent?: string;
    sewingKitType?: SewingKitType;
    shape?: string;
    shortDescription: string;
    size?: string;
    skillLevel?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    swatchImages?: ArtCraftSwatchImage[];
    sweingMachineType?: SewingMachineType;
    theme?: string[];
    variantAttributeNames?: ArtCraftVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface ArtCraftAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export declare enum ArtCraftAgeGroup {
    Adult = "Adult",
    Child = "Child",
    Infant = "Infant",
    Newborn = "Newborn",
    Preemie = "Preemie",
    Senior = "Senior",
    Teen = "Teen",
    Toddler = "Toddler",
    Tween = "Tween"
}
export interface ArtCraftAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ArtCraftAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ArtCraftAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ArtCraftAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BoltLengthYardage {
    measure?: number;
    unit?: BoltLengthYardageUnit;
}
export declare enum BoltLengthYardageUnit {
    Yard = "Yard",
    Yards = "Yards"
}
export declare enum CompositeWoodCertificationCode {
    The1DoesNotContainCompositeWood = "1 - Does not contain composite wood",
    The7NotTSCACompliantAndCannotBeSoldInUS = "7 - Not TSCA compliant and cannot be sold in US",
    The8TSCACompliantAndOkayToBeSoldInUS = "8 - TSCA compliant and okay to be sold in US"
}
export interface ArtCraftDiameter {
    measure?: number;
    unit?: FluffyUnit;
}
export declare enum FluffyUnit {
    CM = "cm",
    In = "in",
    Mm = "mm",
    Μm = "\u00B5m"
}
export interface ArtCraftFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export declare enum FabricPurchaseForm {
    ByTheBolt = "By the bolt",
    ByTheYard = "By the yard",
    Precut = "Precut"
}
export declare enum ArtCraftGender {
    Boys = "Boys",
    Girls = "Girls",
    Men = "Men",
    Unisex = "Unisex",
    Women = "Women"
}
export interface ArtCraftMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export declare enum MaximumRecommendedAgeUnit {
    Months = "months",
    Years = "years"
}
export interface ArtCraftMaximumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export declare enum MetalType {
    BlackGold = "Black Gold",
    BlackGoldPlated = "Black Gold-plated",
    Brass = "Brass",
    Copper = "Copper",
    Goldtone = "Goldtone",
    Iron = "Iron",
    Nickel = "Nickel",
    NoMetal = "No Metal",
    OtherMetal = "Other Metal",
    Palladium = "Palladium",
    Pewter = "Pewter",
    Platinaire = "Platinaire",
    Platinum = "Platinum",
    Rhodium = "Rhodium",
    RoseGold = "Rose Gold",
    RoseGoldPlated = "Rose Gold-plated",
    SilverPlated = "Silver-plated",
    Slivertone = "Slivertone",
    StainlessSteel = "Stainless Steel",
    SterlingSilver = "Sterling Silver",
    Titanium = "Titanium",
    TriToneGold = "Tri-Tone Gold",
    Tungsten = "Tungsten",
    TwoToneGold = "Two-Tone Gold",
    WhiteGold = "White Gold",
    WhiteGoldPlated = "White Gold-plated",
    YellowGold = "Yellow Gold",
    YellowGoldPlated = "Yellow Gold-plated"
}
export interface ArtCraftMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export declare enum PrecutFabricSpecialtySize {
    The10SquaresLayerCakes = "10\" Squares (Layer Cakes)",
    The15Yards = "1.5 Yards",
    The18X21FatQuarters = "18\" X 21\" (Fat Quarters)",
    The1Yard = "1 Yard",
    The25SquaresMiniCharms = "2.5\" Squares (Mini Charms)",
    The25StripsJellyRolls = "2.5\" Strips (Jelly Rolls)",
    The2Yards = "2 Yards",
    The3Yards = "3 Yards",
    The5SquaresCharmPacks = "5\" Squares (Charm Packs)",
    The5X10JollyBars = "5\" X 10\" (Jolly Bars)",
    The5Yard = ".5 Yard",
    The9X21Fat8Ths = "9\" X 21\" (Fat 8ths)"
}
export declare enum SewingKitType {
    HandSewing = "Hand Sewing",
    MachineSewing = "Machine Sewing"
}
export declare enum SmallPartsWarningCode {
    The0NoWarningApplicable = "0 - No warning applicable",
    The1ChokingHazardIsASmallBall = "1 - Choking hazard is a small ball",
    The2ChokingHazardContainsSmallBall = "2 - Choking hazard contains small ball",
    The3ChokingHazardContainsSmallParts = "3 - Choking hazard contains small parts",
    The4ChokingHazardBalloon = "4 - Choking hazard balloon",
    The5ChokingHazardIsAMarble = "5 - Choking hazard is a marble",
    The6ChokingHazardContainsAMarble = "6 - Choking hazard contains a marble"
}
export interface ArtCraftSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ArtCraftVariantAttributeName;
}
export declare enum ArtCraftVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    Finish = "finish",
    Material = "material",
    Scent = "scent",
    Shape = "shape",
    Size = "size"
}
export declare enum SewingMachineType {
    Commercial = "Commercial",
    Computerized = "Computerized",
    Embroidery = "Embroidery",
    Mechanical = "Mechanical",
    Portable = "Portable",
    Sergers = "Sergers"
}
export interface BabyClothing {
    additionalProductAttributes?: BabyClothingAdditionalProductAttribute[];
    ageGroup?: BabyClothingAgeGroup[];
    assembledProductHeight?: BabyClothingAssembledProductHeight;
    assembledProductLength?: BabyClothingAssembledProductLength;
    assembledProductWeight?: BabyClothingAssembledProductWeight;
    assembledProductWidth?: BabyClothingAssembledProductWidth;
    athlete?: string[];
    character?: string[];
    clothingSize: string;
    clothingSizeGroup?: BabyClothingClothingSizeGroup;
    color: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: BabyClothingFabricContent[];
    features?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumRecommendedAge?: BabyClothingMaximumRecommendedAge;
    maximumWeight?: BabyClothingMaximumWeight;
    minimumRecommendedAge?: BabyClothingMinimumRecommendedAge;
    minimumWeight?: BabyClothingMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    outerwearCoatJacketAnVestType?: string;
    pajamaType?: string;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    scent?: string;
    season?: string[];
    seasonCode?: SeasonCode;
    seasonYear?: number;
    shoeCategory?: ShoeCategory;
    shoeClosure?: string;
    shoeSize?: string;
    shoeStyle?: string;
    shoeWidth?: string;
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: BabyClothingSwatchImage[];
    theme?: string[];
    tShirtType?: string[];
    variantAttributeNames?: BabyClothingVariantAttributeName[];
    variantGroupId?: string;
}
export interface BabyClothingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export declare enum BabyClothingAgeGroup {
    Child = "Child",
    Infant = "Infant",
    Newborn = "Newborn",
    Preemie = "Preemie",
    Toddler = "Toddler"
}
export interface BabyClothingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyClothingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyClothingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyClothingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum BabyClothingClothingSizeGroup {
    Infant = "Infant",
    Preemie = "Preemie",
    Toddler = "Toddler"
}
export interface BabyClothingFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export declare enum BabyClothingGender {
    Female = "Female",
    Male = "Male",
    Unisex = "Unisex"
}
export interface BabyClothingMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyClothingMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface BabyClothingMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyClothingMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export declare enum SeasonCode {
    The0Basic = "0- Basic",
    The1Spring = "1- Spring",
    The2Summer = "2- Summer",
    The3BTSFall = "3- BTS/Fall",
    The4Winter = "4- Winter"
}
export declare enum ShoeCategory {
    BabyBoyShoes = "Baby Boy Shoes",
    BabyGirlShoes = "Baby Girl Shoes",
    BoysShoes = "Boys' Shoes",
    GirlsShoes = "Girls' Shoes",
    MenSShoes = "Men's Shoes",
    ToddlerBoyShoes = "Toddler Boy Shoes",
    ToddlerGirlShoes = "Toddler Girl Shoes",
    WomenSShoes = "Women's Shoes"
}
export interface BabyClothingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: PurpleSwatchVariantAttribute;
}
export declare enum PurpleSwatchVariantAttribute {
    BabyClothingSize = "babyClothingSize",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Pattern = "pattern",
    Scent = "scent",
    ShoeSize = "shoeSize",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export declare enum BabyClothingVariantAttributeName {
    Character = "character",
    ClothingSize = "clothingSize",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Pattern = "pattern",
    Scent = "scent",
    ShoeSize = "shoeSize",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface BabyDiaperingCareOther {
    additionalProductAttributes?: BabyDiaperingCareOtherAdditionalProductAttribute[];
    ageGroup?: BabyDiaperingCareOtherAgeGroup[];
    assembledProductHeight?: BabyDiaperingCareOtherAssembledProductHeight;
    assembledProductLength?: BabyDiaperingCareOtherAssembledProductLength;
    assembledProductWeight?: BabyDiaperingCareOtherAssembledProductWeight;
    assembledProductWidth?: BabyDiaperingCareOtherAssembledProductWidth;
    athlete?: string[];
    babyMonitorType?: string[];
    bedSize?: string;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    diaperSize?: string;
    diaposableBabyDiaperType?: string[];
    fabricCareInstructions?: string[];
    fabricContent?: BabyDiaperingCareOtherFabricContent[];
    features?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    ingredients?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: BabyDiaperingCareOtherLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: BabyDiaperingCareOtherMaximumRecommendedAge;
    maximumWeight?: BabyDiaperingCareOtherMaximumWeight;
    minimumRecommendedAge?: BabyDiaperingCareOtherMinimumRecommendedAge;
    minimumWeight?: BabyDiaperingCareOtherMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    scent?: string;
    shelfLife?: BabyDiaperingCareOtherShelfLife;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: BabyDiaperingCareOtherSwatchImage[];
    variantAttributeNames?: BabyDiaperingCareOtherVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface BabyDiaperingCareOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export declare enum BabyDiaperingCareOtherAgeGroup {
    Infant = "Infant",
    Newborn = "Newborn",
    Preemie = "Preemie",
    Toddler = "Toddler"
}
export interface BabyDiaperingCareOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyDiaperingCareOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyDiaperingCareOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyDiaperingCareOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyDiaperingCareOtherFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface BabyDiaperingCareOtherLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export interface BabyDiaperingCareOtherMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyDiaperingCareOtherMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface BabyDiaperingCareOtherMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyDiaperingCareOtherMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyDiaperingCareOtherShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface BabyDiaperingCareOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BabyDiaperingCareOtherVariantAttributeName;
}
export declare enum BabyDiaperingCareOtherVariantAttributeName {
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    DiaperSize = "diaperSize",
    Pattern = "pattern",
    Scent = "scent",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface BabyFood {
    additionalProductAttributes?: BabyFoodAdditionalProductAttribute[];
    ageGroup?: BabyDiaperingCareOtherAgeGroup[];
    babyFoodPackaging?: string;
    babyFoodStage?: string[];
    babyFormulaStage?: string[];
    calories?: BabyFoodCalories;
    caloriesFromFat?: BabyFoodCaloriesFromFat;
    character?: string[];
    containerType?: string[];
    count?: string;
    countPerPack?: number;
    cuisine?: string[];
    features?: string[];
    flavor?: string;
    fluidOuncesSupplying100Calories?: FluidOuncesSupplying100Calories;
    foodAllergenStatements?: string[];
    foodForm?: string;
    foodPreparationTips?: string[];
    globalBrandLicense?: string[];
    ingredients?: string;
    instructions?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: BabyFoodLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    maximumRecommendedAge?: BabyFoodMaximumRecommendedAge;
    meal?: string;
    minimumRecommendedAge?: BabyFoodMinimumRecommendedAge;
    msrp?: number;
    nutrientFootnote?: string;
    nutrients?: BabyFoodNutrient[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    safeHandlingInstructions?: string;
    servingSize?: string;
    servingsPerContainer?: number;
    shelfLife?: BabyFoodShelfLife;
    shortDescription: string;
    size?: string;
    swatchImages?: BabyFoodSwatchImage[];
    totalCarbohydrate?: BabyFoodTotalCarbohydrate;
    totalCarbohydratePercentageDailyValue?: number;
    totalFat?: BabyFoodTotalFat;
    totalFatPercentageDailyValue?: number;
    totalProtein?: BabyFoodTotalProtein;
    totalProteinPercentageDailyValue?: number;
    variantAttributeNames?: BabyFoodVariantAttributeName[];
    variantGroupId?: string;
}
export interface BabyFoodAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BabyFoodCalories {
    measure?: number;
    unit?: CaloriesUnit;
}
export declare enum CaloriesUnit {
    Calories = "Calories"
}
export interface BabyFoodCaloriesFromFat {
    measure?: number;
    unit?: CaloriesUnit;
}
export interface FluidOuncesSupplying100Calories {
    measure?: number;
    unit?: FluidOuncesSupplying100CaloriesUnit;
}
export declare enum FluidOuncesSupplying100CaloriesUnit {
    FLOz = "fl oz"
}
export interface BabyFoodLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export interface BabyFoodMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyFoodMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyFoodNutrient {
    nutrientAmount?: string;
    nutrientName?: string;
    nutrientPercentageDailyValue?: string;
}
export interface BabyFoodShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface BabyFoodSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BabyFoodVariantAttributeName;
}
export declare enum BabyFoodVariantAttributeName {
    Character = "character",
    Count = "count",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    Size = "size"
}
export interface BabyFoodTotalCarbohydrate {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export declare enum TotalCarbohydrateUnit {
    G = "g"
}
export interface BabyFoodTotalFat {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface BabyFoodTotalProtein {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface BabyFurniture {
    additionalProductAttributes?: BabyFurnitureAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: BabyFurnitureAssembledProductHeight;
    assembledProductLength?: BabyFurnitureAssembledProductLength;
    assembledProductWeight?: BabyFurnitureAssembledProductWeight;
    assembledProductWidth?: BabyFurnitureAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    babyCribType?: BabyCribType;
    bedSize?: string;
    character?: string[];
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: BabyFurnitureFabricContent[];
    features?: string[];
    fillMaterial?: string[];
    finish?: string;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    homeDecorStyle?: string;
    isAssemblyRequired?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    mattressFirmness?: string;
    maximumRecommendedAge?: BabyFurnitureMaximumRecommendedAge;
    maximumWeight?: BabyFurnitureMaximumWeight;
    minimumRecommendedAge?: BabyFurnitureMinimumRecommendedAge;
    minimumWeight?: BabyFurnitureMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: BabyFurnitureSwatchImage[];
    variantAttributeNames?: BabyFurnitureVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface BabyFurnitureAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BabyFurnitureAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyFurnitureAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyFurnitureAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyFurnitureAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum BabyCribType {
    ConvertibleCribs = "Convertible Cribs",
    Cradles = "Cradles",
    CribChangerCombos = "Crib & Changer Combos",
    MiniCribs = "Mini Cribs",
    NurserySets = "Nursery Sets",
    PortableCribs = "Portable Cribs",
    StandardCribs = "Standard Cribs"
}
export interface BabyFurnitureFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface BabyFurnitureMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyFurnitureMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface BabyFurnitureMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyFurnitureMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyFurnitureSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BabyFurnitureVariantAttributeName;
}
export declare enum BabyFurnitureVariantAttributeName {
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Pattern = "pattern",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface BabyToys {
    additionalProductAttributes?: BabyToysAdditionalProductAttribute[];
    animalType?: string;
    assembledProductHeight?: BabyToysAssembledProductHeight;
    assembledProductLength?: BabyToysAssembledProductLength;
    assembledProductWeight?: BabyToysAssembledProductWeight;
    assembledProductWidth?: BabyToysAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    awardsWon?: string[];
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    educationalFocus?: string[];
    fabricCareInstructions?: string[];
    fabricContent?: BabyToysFabricContent[];
    features?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    isAssemblyRequired?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    makesNoise?: MustShipAlone;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: BabyToysMaximumRecommendedAge;
    maximumWeight?: BabyToysMaximumWeight;
    minimumRecommendedAge?: BabyToysMinimumRecommendedAge;
    minimumWeight?: BabyToysMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    scent?: string;
    screenSize?: BabyToysScreenSize;
    season?: string[];
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: BabyToysSwatchImage[];
    theme?: string[];
    variantAttributeNames?: BabyToysVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface BabyToysAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BabyToysAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyToysAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyToysAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyToysAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyToysFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface BabyToysMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyToysMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface BabyToysMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyToysMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyToysScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export declare enum ScreenSizeUnit {
    In = "in"
}
export interface BabyToysSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BabyToysVariantAttributeName;
}
export declare enum BabyToysVariantAttributeName {
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Pattern = "pattern",
    Scent = "scent",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface BabyTransport {
    additionalProductAttributes?: BabyTransportAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: BabyTransportAssembledProductHeight;
    assembledProductLength?: BabyTransportAssembledProductLength;
    assembledProductWeight?: BabyTransportAssembledProductWeight;
    assembledProductWidth?: BabyTransportAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    babyCarrierPosition?: string[];
    babyCarrierStyle?: string[];
    carSeatBaseDepth?: CarSeatBaseDepth;
    carSeatBaseWidth?: CarSeatBaseWidth;
    carSeatMaxChildHeight?: CarSeatMaxChildHeight;
    character?: string[];
    childCarSeatType?: ChildCarSeatStyle;
    childWalkingHarnessStyle?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: BabyTransportFabricContent[];
    facingDirection?: string;
    features?: string[];
    forwardFacingMaximumWeight?: ForwardFacingMaximumWeight;
    forwardFacingMinimumWeight?: ForwardFacingMinimumWeight;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    hasLatchSystem?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: BabyTransportMaximumRecommendedAge;
    maximumWeight?: BabyTransportMaximumWeight;
    minimumRecommendedAge?: BabyTransportMinimumRecommendedAge;
    minimumWeight?: BabyTransportMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    rearFacingMaximumWeight?: RearFacingMaximumWeight;
    rearFacingMinimumWeight?: RearFacingMinimumWeight;
    safetyHarnessStyle?: SafetyHarnessStyle;
    seatingCapacity?: number;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    strollerType?: string[];
    swatchImages?: BabyTransportSwatchImage[];
    travelSystemCompatibility?: string;
    variantAttributeNames?: BabyTransportVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface BabyTransportAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BabyTransportAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyTransportAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BabyTransportAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BabyTransportAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CarSeatBaseDepth {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export declare enum CarSeatBaseDepthUnit {
    CM = "cm",
    In = "in"
}
export interface CarSeatBaseWidth {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface CarSeatMaxChildHeight {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export declare enum ChildCarSeatStyle {
    BacklessBooster = "Backless Booster",
    CombinationSeat = "Combination Seat",
    ConvertibleCarSeats = "Convertible Car Seats",
    HighBackBooster = "High-back Booster",
    InfantSeat = "Infant Seat",
    OverheadShieldConvertible = "Overhead Shield Convertible",
    The5PointConvertible = "5-Point Convertible"
}
export interface BabyTransportFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface ForwardFacingMaximumWeight {
    measure?: number;
    unit?: ForwardFacingMaximumWeightUnit;
}
export declare enum ForwardFacingMaximumWeightUnit {
    Kg = "kg",
    LB = "lb"
}
export interface ForwardFacingMinimumWeight {
    measure?: number;
    unit?: ForwardFacingMaximumWeightUnit;
}
export interface BabyTransportMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyTransportMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface BabyTransportMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface BabyTransportMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface RearFacingMaximumWeight {
    measure?: number;
    unit?: ForwardFacingMaximumWeightUnit;
}
export interface RearFacingMinimumWeight {
    measure?: number;
    unit?: ForwardFacingMaximumWeightUnit;
}
export declare enum SafetyHarnessStyle {
    NoHarness = "no harness",
    The3PointHarness = "3-point harness",
    The5PointHarness = "5-point harness"
}
export interface BabyTransportSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BabyTransportVariantAttributeName;
}
export declare enum BabyTransportVariantAttributeName {
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Pattern = "pattern",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface BeautyPersonalCareHygiene {
    absorbency?: string;
    activeIngredients?: BeautyPersonalCareHygieneActiveIngredient[];
    additionalProductAttributes?: BeautyPersonalCareHygieneAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: BeautyPersonalCareHygieneAssembledProductHeight;
    assembledProductLength?: BeautyPersonalCareHygieneAssembledProductLength;
    assembledProductWeight?: BeautyPersonalCareHygieneAssembledProductWeight;
    assembledProductWidth?: BeautyPersonalCareHygieneAssembledProductWidth;
    athlete?: string[];
    batteriesRequired?: MustShipAlone;
    bodyParts?: string[];
    bodySprayType?: BodySprayType;
    cleaningCareAndMaintenance?: string;
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    count?: string;
    countPerPack?: number;
    drugActiveInactiveIngredientsImage?: string;
    drugDosageInstructionsImage?: string;
    features?: string[];
    flavor?: string;
    form?: string;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    hairCareKeyBenefit?: HairCareKeyBenefit[];
    hairColorCategory?: HairColorCategory;
    hairProductForm?: HairProductForm;
    hairType?: string;
    inactiveIngredients?: string[];
    ingredients?: string;
    instructions?: string;
    isAdultProduct?: MustShipAlone;
    isControlledSubstance?: MustShipAlone;
    isDisposable?: MustShipAlone;
    isHypoallergenic?: MustShipAlone;
    isNoncomodegenic?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReusable?: MustShipAlone;
    isSelfTanning?: MustShipAlone;
    isSet?: MustShipAlone;
    isTinted?: MustShipAlone;
    isTravelSize?: MustShipAlone;
    isUnscented?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: BeautyPersonalCareHygieneLabelImage[];
    mainImageUrl: string;
    makeupForm?: MakeupForm[];
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    medicineStrength?: string;
    modelNumber?: string;
    msrp?: number;
    perfumeCologneType?: PerfumeCologneType;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    resultTime?: ResultTime;
    scent?: string;
    shortDescription: string;
    size?: string;
    skinCareConcern?: string[];
    skinTone?: string;
    skinType?: string;
    spfValue?: number;
    sportsLeague?: string[];
    sportsTeam?: string[];
    stopUseIndications?: string[];
    swatchImages?: BeautyPersonalCareHygieneSwatchImage[];
    variantAttributeNames?: BeautyPersonalCareHygieneVariantAttributeName[];
    variantGroupId?: string;
    wigCapStyle?: WigCapStyle;
}
export interface BeautyPersonalCareHygieneActiveIngredient {
    activeIngredientName?: string;
    activeIngredientPercentage?: number;
}
export interface BeautyPersonalCareHygieneAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BeautyPersonalCareHygieneAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BeautyPersonalCareHygieneAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BeautyPersonalCareHygieneAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BeautyPersonalCareHygieneAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum BodySprayType {
    Mist = "Mist",
    Spray = "Spray"
}
export declare enum HairCareKeyBenefit {
    Clarifying = "Clarifying",
    ColorProtection = "Color Protection",
    CurlEnhancing = "Curl Enhancing",
    DandruffRelief = "Dandruff Relief",
    FrizzControl = "Frizz Control",
    GrayReduction = "Gray Reduction",
    HeatProtection = "Heat Protection",
    Moisturizing = "Moisturizing",
    StrengtheningSplitEndRepair = "Strengthening & Split End Repair",
    Thickening = "Thickening",
    Volumizing = "Volumizing"
}
export declare enum HairColorCategory {
    Auburn = "Auburn",
    Black = "Black",
    Blonde = "Blonde",
    Brown = "Brown",
    Grey = "Grey",
    NonNatural = "Non-Natural",
    Red = "Red",
    Silver = "Silver",
    White = "White"
}
export declare enum HairProductForm {
    Bars = "Bars",
    Creams = "Creams",
    Fibers = "Fibers",
    Gels = "Gels",
    Liquids = "Liquids",
    Mousses = "Mousses",
    Oils = "Oils",
    Pomades = "Pomades",
    Sprays = "Sprays",
    Sticks = "Sticks",
    Tablets = "Tablets",
    Waxes = "Waxes"
}
export interface BeautyPersonalCareHygieneLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export declare enum MakeupForm {
    Balms = "Balms",
    Crayons = "Crayons",
    Creams = "Creams",
    Cushions = "Cushions",
    Gels = "Gels",
    Glosses = "Glosses",
    Liquids = "Liquids",
    LoosePowders = "Loose Powders",
    Mousses = "Mousses",
    Pencils = "Pencils",
    PressedPowdersOils = "Pressed Powders: Oils",
    Sprays = "Sprays",
    Sticks = "Sticks",
    Tubes = "Tubes",
    Wipes = "Wipes"
}
export declare enum PerfumeCologneType {
    Colognes = "Colognes",
    Perfumes = "Perfumes"
}
export interface ResultTime {
    measure?: number;
    unit?: ResultTimeUnit;
}
export declare enum ResultTimeUnit {
    H = "h",
    Min = "min"
}
export interface BeautyPersonalCareHygieneSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BeautyPersonalCareHygieneVariantAttributeName;
}
export declare enum BeautyPersonalCareHygieneVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    MedicineStrength = "medicineStrength",
    Scent = "scent",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export declare enum WigCapStyle {
    FullLace = "Full Lace",
    LaceFrontWigCaps = "Lace Front Wig Caps",
    Monofiliment = "Monofiliment",
    The100HandTied = "100% Hand-Tied",
    ThinSkinWigCaps = "Thin Skin Wig Caps",
    WeftedWigCaps = "Wefted Wig Caps"
}
export interface Bedding {
    additionalProductAttributes?: BeddingAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: BeddingAssembledProductHeight;
    assembledProductLength?: BeddingAssembledProductLength;
    assembledProductWeight?: BeddingAssembledProductWeight;
    assembledProductWidth?: BeddingAssembledProductWidth;
    athlete?: string[];
    bedPillowSize?: string[];
    bedSize?: string;
    bedStyle?: string;
    character?: string[];
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: BeddingFabricContent[];
    features?: string[];
    fillMaterial?: string[];
    gender?: ArtCraftGender;
    globalBrandLicense?: string[];
    homeDecorStyle?: string;
    isPrimaryVariant?: MustShipAlone;
    isSet?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    mattressFirmness?: string;
    modelNumber?: string;
    monogramLetter?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: BeddingSwatchImage[];
    theme?: string[];
    threadCount?: number;
    variantAttributeNames?: BeddingVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface BeddingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BeddingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BeddingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BeddingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BeddingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BeddingFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface BeddingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BeddingVariantAttributeName;
}
export declare enum BeddingVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    BedSize = "bedSize",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    FabricMaterialName = "fabricMaterialName",
    Firmness = "Firmness",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface BuildingSupply {
    accessoriesIncluded?: string[];
    acRating?: ACRating;
    additionalProductAttributes?: BuildingSupplyAdditionalProductAttribute[];
    assembledProductHeight?: BuildingSupplyAssembledProductHeight;
    assembledProductLength?: BuildingSupplyAssembledProductLength;
    assembledProductWeight?: BuildingSupplyAssembledProductWeight;
    assembledProductWidth?: BuildingSupplyAssembledProductWidth;
    carpetStyle?: string;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    coverageArea?: BuildingSupplyCoverageArea;
    doorOpeningStyle?: string;
    doorStyle?: string;
    dryTime?: DryTime;
    features?: string[];
    fineness?: string;
    form?: string;
    globalBrandLicense?: string[];
    grade?: string;
    hasLowEmissivity?: MustShipAlone;
    ingredients?: string;
    isBiodegradable?: MustShipAlone;
    isCombustible?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isFastSetting?: MustShipAlone;
    isFireResistant?: MustShipAlone;
    isFlammable?: MustShipAlone;
    isMadeFromReclaimedMaterials?: MustShipAlone;
    isMadeFromRecycledMaterial?: MustShipAlone;
    isMadeFromSustainableMaterials?: MustShipAlone;
    isMoldResistant?: MustShipAlone;
    isOdorless?: MustShipAlone;
    isPrefinished?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReadyToUse?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWaterSoluble?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    paintFinish?: string;
    pattern?: string[];
    peiRating?: string;
    pieceCount?: number;
    pileHeight?: PileHeight;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedSurfaces?: string[];
    recommendedUses?: string[];
    recycledMaterialContent?: BuildingSupplyRecycledMaterialContent[];
    rollLength?: RollLength;
    shape?: string;
    shortDescription: string;
    size?: string;
    snowLoadRating?: SnowLoadRating;
    swatchImages?: BuildingSupplySwatchImage[];
    thickness?: Thickness;
    variantAttributeNames?: BuildingSupplyVariantAttributeName[];
    variantGroupId?: string;
    vocLevel?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export declare enum ACRating {
    Ac1 = "AC1",
    Ac2 = "AC2",
    Ac3 = "AC3",
    Ac4 = "AC4",
    Ac5 = "AC5"
}
export interface BuildingSupplyAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BuildingSupplyAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BuildingSupplyAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BuildingSupplyAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface BuildingSupplyAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BuildingSupplyCoverageArea {
    measure?: number;
    unit?: CoverageAreaUnit;
}
export declare enum CoverageAreaUnit {
    SqFt = "sq ft"
}
export interface DryTime {
    measure?: number;
    unit?: ResultTimeUnit;
}
export interface PileHeight {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface BuildingSupplyRecycledMaterialContent {
    percentageOfRecycledMaterial?: number;
    recycledMaterial?: string;
}
export interface RollLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SnowLoadRating {
    measure?: number;
    unit?: SnowLoadRatingUnit;
}
export declare enum SnowLoadRatingUnit {
    Psf = "psf",
    Psi = "psi"
}
export interface BuildingSupplySwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BuildingSupplyVariantAttributeName;
}
export declare enum BuildingSupplyVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Grade = "grade",
    PaintFinish = "paintFinish",
    Shape = "shape",
    Size = "size"
}
export interface Thickness {
    measure?: number;
    unit?: ThicknessUnit;
}
export declare enum ThicknessUnit {
    In = "in",
    Mil = "mil"
}
export interface CamerasLenses {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: CamerasLensesAdditionalProductAttribute[];
    assembledProductHeight?: CamerasLensesAssembledProductHeight;
    assembledProductLength?: CamerasLensesAssembledProductLength;
    assembledProductWeight?: CamerasLensesAssembledProductWeight;
    assembledProductWidth?: CamerasLensesAssembledProductWidth;
    assemblyInstructions?: string;
    attachmentStyle?: string;
    cameraLensType?: string;
    capacity?: string;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    compatibleDevices?: string[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    diameter?: CamerasLensesDiameter;
    digitalZoom?: string;
    displayResolution?: string[];
    displayTechnology?: string;
    exposureModes?: string[];
    features?: string[];
    fieldOfView?: string;
    flashType?: string;
    focalLength?: FocalLength;
    focalRatio?: string;
    focusType?: string[];
    globalBrandLicense?: string[];
    hasFlash?: MustShipAlone;
    hasHandle?: MustShipAlone;
    hasMemoryCardSlot?: MustShipAlone;
    hasNightVision?: MustShipAlone;
    hasRedEyeReduction?: MustShipAlone;
    hasSelfTimer?: MustShipAlone;
    hasShoulderStrap?: MustShipAlone;
    hasTouchscreen?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isFogResistant?: MustShipAlone;
    isMulticoated?: MustShipAlone;
    isParfocal?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    lensCoating?: string;
    lensDiameter?: CamerasLensesLensDiameter;
    lensFilterType?: string;
    magnification?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumAperture?: string;
    maximumShutterSpeed?: MaximumShutterSpeed;
    memoryCardType?: string[];
    microphoneIncluded?: MustShipAlone;
    minimumAperture?: string;
    minimumShutterSpeed?: MinimumShutterSpeed;
    modelNumber?: string;
    msrp?: number;
    numberOfMegapixels?: NumberOfMegapixels;
    opticalZoom?: string;
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recordableMediaFormats?: string[];
    screenSize?: CamerasLensesScreenSize;
    selfTimerDelay?: string[];
    sensorResolution?: string;
    shootingMode?: string;
    shortDescription: string;
    standbyTime?: CamerasLensesStandbyTime;
    swatchImages?: CamerasLensesSwatchImage[];
    variantAttributeNames?: CamerasLensesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface CamerasLensesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CamerasLensesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CamerasLensesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CamerasLensesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CamerasLensesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CamerasLensesDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export declare enum RoughInDistanceUnit {
    CM = "cm",
    Ft = "ft",
    In = "in",
    Mm = "mm"
}
export interface FocalLength {
    measure?: string;
    unit?: FocalLengthUnit;
}
export declare enum FocalLengthUnit {
    Mm = "mm"
}
export interface CamerasLensesLensDiameter {
    measure?: number;
    unit?: FocalLengthUnit;
}
export interface MaximumShutterSpeed {
    measure?: string;
    unit?: MaximumShutterSpeedUnit;
}
export declare enum MaximumShutterSpeedUnit {
    S = "s"
}
export interface MinimumShutterSpeed {
    measure?: string;
    unit?: MaximumShutterSpeedUnit;
}
export interface NumberOfMegapixels {
    measure?: number;
    unit?: NumberOfMegapixelsUnit;
}
export declare enum NumberOfMegapixelsUnit {
    Mp = "MP"
}
export interface CamerasLensesScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface CamerasLensesStandbyTime {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export declare enum StandbyTimeUnit {
    H = "h"
}
export interface CamerasLensesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CamerasLensesVariantAttributeName;
}
export declare enum CamerasLensesVariantAttributeName {
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    Diameter = "diameter",
    DisplayResolution = "displayResolution",
    FocalLength = "focalLength",
    Material = "material",
    Size = "size"
}
export interface CarriersAccessories {
    additionalProductAttributes?: CarriersAccessoriesAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: CarriersAccessoriesAssembledProductHeight;
    assembledProductLength?: CarriersAccessoriesAssembledProductLength;
    assembledProductWeight?: CarriersAccessoriesAssembledProductWeight;
    assembledProductWidth?: CarriersAccessoriesAssembledProductWidth;
    athlete?: string[];
    autographedBy?: string;
    bagCaseFeature?: string;
    bagStyle?: BagStyle[];
    capacity?: string;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    designer?: string;
    dimensions?: string;
    fabricCareInstructions?: string[];
    fabricContent?: CarriersAccessoriesFabricContent[];
    features?: string[];
    gender?: ArtCraftGender;
    globalBrandLicense?: string[];
    handleMaterial?: string[];
    handleType?: string;
    isFairTrade?: MustShipAlone;
    isLined?: MustShipAlone;
    isMadeFromRecycledMaterial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    leatherGrade?: string;
    lockingMechanism?: string;
    luggageStyle?: string;
    luggageType?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    monogramLetter?: string;
    msrp?: number;
    numberOfWheels?: number;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recycledMaterialContent?: CarriersAccessoriesRecycledMaterialContent[];
    scarfStyle?: string[];
    seasonCode?: SeasonCode;
    seasonYear?: number;
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: CarriersAccessoriesSwatchImage[];
    variantAttributeNames?: CarriersAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    zipperMaterial?: string;
}
export interface CarriersAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CarriersAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CarriersAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CarriersAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CarriersAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum BagStyle {
    Backpack = "Backpack",
    BeachBag = "Beach Bag",
    BeltBagFannyPack = "Belt Bag/Fanny Pack",
    Briefcase = "Briefcase",
    ClutchEveningBag = "Clutch/Evening Bag",
    CrossbodyBag = "Crossbody Bag",
    GymBag = "Gym Bag",
    HoboBag = "Hobo Bag",
    Other = "Other:",
    Satchel = "Satchel",
    ShoulderBag = "Shoulder Bag",
    ToteBag = "Tote Bag",
    WalletCardCase = "Wallet/Card Case",
    WeekenderDuffelBag = "Weekender/Duffel Bag"
}
export interface CarriersAccessoriesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface CarriersAccessoriesRecycledMaterialContent {
    percentageOfRecycledMaterial?: number;
    recycledMaterial?: string;
}
export interface CarriersAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CarriersAccessoriesVariantAttributeName;
}
export declare enum CarriersAccessoriesVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    BagStyle = "bagStyle",
    Capacity = "capacity",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    MonogramLetter = "monogramLetter",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface CasesBags {
    additionalProductAttributes?: CasesBagsAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: CasesBagsAssembledProductHeight;
    assembledProductLength?: CasesBagsAssembledProductLength;
    assembledProductWeight?: CasesBagsAssembledProductWeight;
    assembledProductWidth?: CasesBagsAssembledProductWidth;
    athlete?: string[];
    autographedBy?: string;
    capacity?: string;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    compatibleDevices?: string[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    designer?: string;
    fabricCareInstructions?: string[];
    fabricContent?: CasesBagsFabricContent[];
    fastenerType?: string;
    features?: string[];
    finish?: string;
    gender?: ArtCraftGender;
    globalBrandLicense?: string[];
    handleMaterial?: string[];
    handleType?: string;
    hardOrSoftCase?: HardOrSoftCase;
    hasRemovableStrap?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isLined?: MustShipAlone;
    isMadeFromRecycledMaterial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReusable?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    leatherGrade?: string;
    lockingMechanism?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumWeight?: CasesBagsMaximumWeight;
    modelNumber?: string;
    monogramLetter?: string;
    msrp?: number;
    numberOfCompartments?: number;
    numberOfWheels?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    recycledMaterialContent?: CasesBagsRecycledMaterialContent[];
    screenSize?: CasesBagsScreenSize;
    seasonCode?: SeasonCode;
    seasonYear?: number;
    shape?: string;
    shortDescription: string;
    size?: string;
    sport?: string[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: CasesBagsSwatchImage[];
    variantAttributeNames?: CarriersAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    zipperMaterial?: string;
}
export interface CasesBagsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CasesBagsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CasesBagsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CasesBagsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CasesBagsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CasesBagsFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export declare enum HardOrSoftCase {
    Hard = "Hard",
    Soft = "Soft"
}
export interface CasesBagsMaximumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CasesBagsRecycledMaterialContent {
    percentageOfRecycledMaterial?: number;
    recycledMaterial?: string;
}
export interface CasesBagsScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface CasesBagsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CarriersAccessoriesVariantAttributeName;
}
export interface CellPhones {
    additionalProductAttributes?: CellPhonesAdditionalProductAttribute[];
    batteryLife?: CellPhonesBatteryLife;
    cellPhoneServiceProvider?: string;
    cellPhoneType?: string;
    cellularNetworkTechnology?: string;
    color?: string[];
    compatibleModels?: string[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    edition?: string;
    features?: string[];
    frontFacingCameraMegapixels?: CellPhonesFrontFacingCameraMegapixels;
    hardDriveCapacity?: CellPhonesHardDriveCapacity;
    hasFlash?: MustShipAlone;
    hasSignalBooster?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    memoryCardType?: string[];
    mobileOperatingSystem?: string[];
    modelName?: string;
    modelNumber?: string;
    msrp?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    ramMemory?: CellPhonesRAMMemory;
    rearCameraMegapixels?: CellPhonesRearCameraMegapixels;
    resolution?: string;
    screenSize?: CellPhonesScreenSize;
    shortDescription: string;
    standbyTime?: CellPhonesStandbyTime;
    swatchImages?: CellPhonesSwatchImage[];
    talkTime?: TalkTime;
    variantAttributeNames?: CellPhonesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface CellPhonesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CellPhonesBatteryLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface CellPhonesFrontFacingCameraMegapixels {
    measure?: number;
    unit?: NumberOfMegapixelsUnit;
}
export interface CellPhonesHardDriveCapacity {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export declare enum HardDriveCapacityUnit {
    GB = "GB",
    KB = "KB",
    MB = "MB",
    Pb = "PB",
    TB = "TB"
}
export interface CellPhonesRAMMemory {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface CellPhonesRearCameraMegapixels {
    measure?: number;
    unit?: NumberOfMegapixelsUnit;
}
export interface CellPhonesScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface CellPhonesStandbyTime {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface CellPhonesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: FluffySwatchVariantAttribute;
}
export declare enum FluffySwatchVariantAttribute {
    CellPhoneServiceProvider = "cellPhoneServiceProvider",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export interface TalkTime {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export declare enum CellPhonesVariantAttributeName {
    CellPhoneServiceProvider = "cellPhoneServiceProvider",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize"
}
export interface CeremonialClothingAccessories {
    additionalProductAttributes?: CeremonialClothingAccessoriesAdditionalProductAttribute[];
    assembledProductHeight?: CeremonialClothingAccessoriesAssembledProductHeight;
    assembledProductLength?: CeremonialClothingAccessoriesAssembledProductLength;
    assembledProductWeight?: CeremonialClothingAccessoriesAssembledProductWeight;
    assembledProductWidth?: CeremonialClothingAccessoriesAssembledProductWidth;
    clothingSize?: string;
    clothingSizeGroup?: CeremonialClothingAccessoriesClothingSizeGroup;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: CeremonialClothingAccessoriesFabricContent[];
    features?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    swatchImages?: CeremonialClothingAccessoriesSwatchImage[];
    theme?: string[];
    variantAttributeNames?: CeremonialClothingAccessoriesVariantAttributeName[];
    variantGroupId?: string;
}
export interface CeremonialClothingAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CeremonialClothingAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CeremonialClothingAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CeremonialClothingAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CeremonialClothingAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum CeremonialClothingAccessoriesClothingSizeGroup {
    BigBoys = "Big Boys",
    BigBoysHusky = "Big Boys Husky",
    BigBoysSlim = "Big Boys Slim",
    BigGirls = "Big Girls",
    BigGirlsPlus = "Big Girls Plus",
    BigGirlsSlim = "Big Girls Slim",
    BigTall = "Big & Tall",
    Infant = "Infant",
    Juniors = "Juniors",
    LittleBoys = "Little Boys",
    LittleBoysHusky = "Little Boys Husky",
    LittleBoysSlim = "Little Boys Slim",
    LittleGirls = "Little Girls",
    LittleGirlsPlus = "Little Girls Plus",
    LittleGirlsSlim = "Little Girls Slim",
    Maternity = "Maternity",
    MaternityPlus = "Maternity Plus",
    Men = "Men",
    Newborn = "Newborn",
    Petite = "Petite",
    PetitePlus = "Petite Plus",
    Plus = "Plus",
    Preemie = "Preemie",
    Regular = "Regular",
    Short = "Short",
    Tall = "Tall",
    Toddler = "Toddler",
    Women = "Women",
    WomenSPlus = "Women's Plus",
    YoungMenS = "Young Men\u2019s"
}
export interface CeremonialClothingAccessoriesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface CeremonialClothingAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CeremonialClothingAccessoriesVariantAttributeName;
}
export declare enum CeremonialClothingAccessoriesVariantAttributeName {
    ClothingSize = "clothingSize",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Occasion = "occasion",
    Pattern = "pattern",
    Size = "size",
    Theme = "theme"
}
export interface Clothing {
    academicInstitution?: string;
    accentColor?: string;
    activity?: string[];
    additionalProductAttributes?: ClothingAdditionalProductAttribute[];
    ageGroup: ArtCraftAgeGroup[];
    athlete?: string[];
    autographedBy?: string;
    beltBuckleStyle?: string;
    beltStyle?: string[];
    braBandSize?: BraBandSize;
    braCupSize?: string;
    braSize?: string;
    braStyle?: string[];
    character?: string[];
    chestSize?: ChestSize;
    clothingCut?: string[];
    clothingFit?: string;
    clothingLengthStyle?: string;
    clothingSize: string;
    clothingSizeGroup?: CeremonialClothingAccessoriesClothingSizeGroup;
    clothingStyle?: string[];
    clothingTopStyle?: string[];
    clothingWeight?: ClothingWeight;
    collarType?: string;
    color: string[];
    colorCategory: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    dressShirtSize?: string;
    dressStyle?: string;
    fabricCareInstructions?: string[];
    fabricContent?: ClothingFabricContent[];
    fastenerType?: string;
    features?: string[];
    gender: BabyClothingGender;
    globalBrandLicense?: string[];
    gotsCertification?: MustShipAlone;
    hatSize?: HatSizeMeasurement;
    hatStyle?: string[];
    hosieryStyle?: string[];
    inseam?: Inseam;
    isMaternity?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isSet?: MustShipAlone;
    jacketStyle?: string[];
    jeanFinish?: string[];
    jeanStyle?: string[];
    jeanWash?: string;
    keyFeatures?: string[];
    legOpeningCut?: LegOpeningCut;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    neckSize?: NeckSize;
    occasion?: string[];
    outerwearCoatJacketAnVestType?: string;
    pajamaType?: string;
    pantFit?: string[];
    pantLegCut?: PantLegCut;
    pantRise?: string;
    pantSize?: string;
    pantStyle?: string;
    pantySize?: PantySize;
    pantyStyle?: string;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recycledMaterialContent?: ClothingRecycledMaterialContent[];
    scarfStyle?: string[];
    season?: string[];
    seasonCode?: SeasonCode;
    seasonYear?: number;
    shirtNeckStyle?: string;
    shoeSize?: string;
    shortDescription: string;
    shortsStyle?: string[];
    skirtAndDressCut?: string[];
    skirtLength?: SkirtLength;
    skirtLengthStyle?: string;
    sleeveLength?: SleeveLength;
    sleeveLengthStyle?: SleeveLengthStyle;
    sleeveStyle?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sockRise?: SockRise;
    sockSize?: string;
    sockStyle?: string;
    sport?: string[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    suitBreastingStyle?: SuitBreastingStyle;
    swatchImages?: ClothingSwatchImage[];
    sweaterStyle?: string[];
    swimsuitStyle?: string;
    theme?: string[];
    tightsSheerness?: Sheerness;
    tShirtType?: string[];
    underpantsType?: string;
    underwearStyle?: string[];
    upperBodyStrapConfiguration?: string[];
    variantAttributeNames?: ClothingVariantAttributeName[];
    variantGroupId?: string;
    waistSize?: WaistSize;
    waistStyle?: WaistStyle[];
    warrantyText?: string;
    warrantyURL?: string;
    weather?: string[];
}
export interface ClothingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BraBandSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ChestSize {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export declare enum ClothingWeight {
    Heavyweight = "Heavyweight",
    Lightweight = "Lightweight",
    MidWeight = "Mid-Weight"
}
export interface ClothingFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export declare enum HatSizeMeasurement {
    The612 = "6 1/2",
    The614 = "6 1/4",
    The634 = "6 3/4",
    The638 = "6 3/8",
    The658 = "6 5/8",
    The678 = "6 7/8",
    The7 = "7",
    The712 = "7 1/2",
    The714 = "7 1/4",
    The718 = "7 1/8",
    The734 = "7 3/4",
    The738 = "7 3/8",
    The758 = "7 5/8",
    The778 = "7 7/8",
    The8 = "8",
    The818 = "8 1/8"
}
export interface Inseam {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export declare enum LegOpeningCut {
    AtHip = "At Hip",
    BelowHip = "Below Hip",
    HighCut = "High-Cut",
    Regular = "Regular"
}
export interface NeckSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export declare enum PantLegCut {
    BootCut = "Boot Cut",
    FlareLeg = "Flare-Leg",
    SlimLeg = "Slim-Leg",
    StraightLeg = "Straight-Leg",
    Taper = "Taper",
    WideLeg = "Wide-Leg"
}
export declare enum PantySize {
    The0 = "0",
    The1 = "1",
    The10 = "10",
    The11 = "11",
    The12 = "12",
    The13 = "13",
    The14 = "14",
    The15 = "15",
    The16 = "16",
    The17 = "17",
    The18 = "18",
    The19 = "19",
    The2 = "2",
    The20 = "20",
    The21 = "21",
    The22 = "22",
    The23 = "23",
    The24 = "24",
    The25 = "25",
    The26 = "26",
    The27 = "27",
    The28 = "28",
    The29 = "29",
    The3 = "3",
    The30 = "30",
    The31 = "31",
    The32 = "32",
    The33 = "33",
    The34 = "34",
    The4 = "4",
    The5 = "5",
    The6 = "6",
    The7 = "7",
    The8 = "8",
    The9 = "9"
}
export interface ClothingRecycledMaterialContent {
    percentageOfRecycledMaterial?: number;
    recycledMaterial?: string;
}
export interface SkirtLength {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface SleeveLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export declare enum SleeveLengthStyle {
    ElbowLength = "Elbow-Length",
    LongSleeve = "Long Sleeve",
    ShortSleeve = "Short Sleeve",
    Sleeveless = "Sleeveless",
    The14Sleeve = "1/4 Sleeve",
    The34Sleeve = "3/4 Sleeve"
}
export declare enum SockRise {
    Crew = "Crew",
    KneeHigh = "Knee-High",
    LowCut = "Low-Cut",
    NoShow = "No-Show",
    Quarter = "Quarter",
    ThighHigh = "Thigh-High"
}
export declare enum SuitBreastingStyle {
    DoubleBreasted = "Double-Breasted",
    SingleBreasted = "Single-Breasted"
}
export interface ClothingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ClothingVariantAttributeName;
}
export declare enum ClothingVariantAttributeName {
    AcademicInstitution = "academicInstitution",
    AccentColor = "accentColor",
    BraBandSize = "braBandSize",
    BraCupSize = "braCupSize",
    BraSize = "braSize",
    Character = "character",
    ClothingFit = "clothingFit",
    ClothingSize = "clothingSize",
    ClothingSizeGroup = "clothingSizeGroup",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    HatSize = "hatSize",
    Inseam = "inseam",
    Material = "material",
    NeckSize = "neckSize",
    PantySize = "pantySize",
    Pattern = "pattern",
    ShoeSize = "shoeSize",
    SockSize = "sockSize",
    SportsTeam = "sportsTeam",
    WaistSize = "waistSize"
}
export declare enum Sheerness {
    Opaque = "Opaque",
    SemiOpaque = "Semi-Opaque",
    Sheer = "Sheer",
    ThickOpaque = "Thick Opaque",
    UltraSheer = "Ultra-Sheer"
}
export interface WaistSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export declare enum WaistStyle {
    BandedWaist = "Banded Waist",
    ComfortWaist = "Comfort Waist",
    DropWaist = "Drop Waist",
    ElasticWaist = "Elastic Waist",
    EmpireWaist = "Empire Waist",
    ExpandableWaist = "Expandable Waist",
    MaternityWaist = "Maternity Waist",
    PaperBagWaist = "Paper Bag Waist",
    RigidWaist = "Rigid Waist",
    RoseWaist = "Rose-Waist",
    SeamlessWaistband = "Seamless Waistband"
}
export interface ComputerComponents {
    additionalProductAttributes?: ComputerComponentsAdditionalProductAttribute[];
    cableLength?: ComputerComponentsCableLength;
    color?: string[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    cpuSocketType?: string[];
    dataIntegrityCheck?: DataIntegrityCheck;
    edition?: string;
    features?: string[];
    hardDriveCapacity?: ComputerComponentsHardDriveCapacity;
    internalExternal?: InternalExternal;
    isCordless?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumRamSupported?: ComputerComponentsMaximumRAMSupported;
    memoryCardType?: string[];
    modelNumber?: string;
    motherboardFormFactor?: string[];
    mountType?: string[];
    msrp?: number;
    numberOfChannels?: string;
    numberOfKeys?: number;
    numberOfSpeakers?: number;
    pieceCount?: number;
    processorSpeed?: ComputerComponentsProcessorSpeed;
    processorType?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    rackSize?: string;
    RAIDlevel?: RAIDLevel;
    ramMemory?: ComputerComponentsRAMMemory;
    RAMSpeed?: string;
    resolution?: string;
    screenSize?: ComputerComponentsScreenSize;
    shortDescription: string;
    swatchImages?: ComputerComponentsSwatchImage[];
    variantAttributeNames?: ComputerComponentsVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export declare enum RAIDLevel {
    RAID0 = "RAID 0",
    RAID1 = "RAID 1",
    RAID2 = "RAID 2",
    RAID3 = "RAID 3",
    RAID4 = "RAID 4",
    RAID5 = "RAID 5",
    RAID6 = "RAID 6"
}
export interface ComputerComponentsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ComputerComponentsCableLength {
    measure?: number;
    unit?: CableLengthUnit;
}
export declare enum CableLengthUnit {
    CM = "cm",
    Ft = "ft",
    In = "in",
    M = "m"
}
export declare enum DataIntegrityCheck {
    ECC = "ECC",
    NonECC = "Non-ECC"
}
export interface ComputerComponentsHardDriveCapacity {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export declare enum InternalExternal {
    External = "External",
    Internal = "Internal"
}
export interface ComputerComponentsMaximumRAMSupported {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface ComputerComponentsProcessorSpeed {
    measure?: number;
    unit?: ProcessorSpeedUnit;
}
export declare enum ProcessorSpeedUnit {
    GHz = "GHz",
    Hz = "Hz",
    KHz = "kHz",
    MHz = "MHz"
}
export interface ComputerComponentsRAMMemory {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface ComputerComponentsScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ComputerComponentsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: TentacledSwatchVariantAttribute;
}
export declare enum TentacledSwatchVariantAttribute {
    CableLength = "cableLength",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    MountType = "mountType",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export declare enum ComputerComponentsVariantAttributeName {
    CableLength = "cableLength",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    MountType = "mountType",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize"
}
export interface Computers {
    additionalProductAttributes?: ComputersAdditionalProductAttribute[];
    batteryLife?: ComputersBatteryLife;
    color?: string[];
    colorCategory?: ColorCategory[];
    computerStyle?: string;
    connections?: string[];
    count?: string;
    countPerPack?: number;
    dataIntegrityCheck?: DataIntegrityCheck;
    displayTechnology?: string;
    edition?: string;
    features?: string[];
    formFactor?: string;
    frontFacingCameraMegapixels?: ComputersFrontFacingCameraMegapixels;
    globalBrandLicense?: string[];
    graphicsInformation?: string;
    hardDriveCapacity?: ComputersHardDriveCapacity;
    hasSignalBooster?: MustShipAlone;
    hasTouchscreen?: MustShipAlone;
    internalExternal?: InternalExternal;
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumRamSupported?: ComputersMaximumRAMSupported;
    memoryCardType?: string[];
    modelNumber?: string;
    mountType?: string[];
    msrp?: number;
    numberOfChannels?: string;
    numberOfKeys?: number;
    operatingSystem?: string[];
    opticalDrive?: string;
    processorSpeed?: ComputersProcessorSpeed;
    processorType?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    RAIDlevel?: RAIDLevel;
    ramMemory?: ComputersRAMMemory;
    RAMSpeed?: string;
    rearCameraMegapixels?: ComputersRearCameraMegapixels;
    resolution?: string;
    screenSize?: ComputersScreenSize;
    shortDescription: string;
    swatchImages?: ComputersSwatchImage[];
    variantAttributeNames?: ComputersVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface ComputersAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ComputersBatteryLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface ComputersFrontFacingCameraMegapixels {
    measure?: number;
    unit?: NumberOfMegapixelsUnit;
}
export interface ComputersHardDriveCapacity {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface ComputersMaximumRAMSupported {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface ComputersProcessorSpeed {
    measure?: number;
    unit?: ProcessorSpeedUnit;
}
export interface ComputersRAMMemory {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface ComputersRearCameraMegapixels {
    measure?: number;
    unit?: NumberOfMegapixelsUnit;
}
export interface ComputersScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ComputersSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: StickySwatchVariantAttribute;
}
export declare enum StickySwatchVariantAttribute {
    Color = "color",
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    OperatingSystem = "operatingSystem",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export declare enum ComputersVariantAttributeName {
    Color = "color",
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    OperatingSystem = "operatingSystem",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize"
}
export interface Costumes {
    additionalProductAttributes?: CostumesAdditionalProductAttribute[];
    animalType?: string;
    assembledProductHeight?: CostumesAssembledProductHeight;
    assembledProductLength?: CostumesAssembledProductLength;
    assembledProductWeight?: CostumesAssembledProductWeight;
    assembledProductWidth?: CostumesAssembledProductWidth;
    character?: string[];
    clothingSize?: string;
    clothingSizeGroup?: CeremonialClothingAccessoriesClothingSizeGroup;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricCareInstructions?: string[];
    fabricContent?: CostumesFabricContent[];
    features?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    swatchImages?: CostumesSwatchImage[];
    targetAudience?: string[];
    theme?: string[];
    variantAttributeNames?: CostumesVariantAttributeName[];
    variantGroupId?: string;
    wigStyles?: string[];
}
export interface CostumesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CostumesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CostumesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CostumesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CostumesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CostumesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface CostumesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CostumesVariantAttributeName;
}
export declare enum CostumesVariantAttributeName {
    Character = "character",
    ClothingSize = "clothingSize",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Occasion = "occasion",
    Pattern = "pattern",
    Size = "size",
    Theme = "theme"
}
export interface Cycling {
    additionalProductAttributes?: CyclingAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: CyclingAssembledProductHeight;
    assembledProductLength?: CyclingAssembledProductLength;
    assembledProductWeight?: CyclingAssembledProductWeight;
    assembledProductWidth?: CyclingAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    bicycleFrameSize?: BicycleFrameSize;
    bicycleTireSize?: string;
    bicycleWheelDiameter?: BicycleWheelDiameter;
    capacity?: string;
    character?: string[];
    cleaningCareAndMaintenance?: string;
    clothingSize?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    dexterity?: string;
    fabricCareInstructions?: string[];
    fabricContent?: CyclingFabricContent[];
    features?: string[];
    finish?: string;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    horsepower?: CyclingHorsepower;
    isAssemblyRequired?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    keyFeatures?: string[];
    lightBulbType?: string;
    lockingMechanism?: string;
    lockType?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: CyclingMaximumRecommendedAge;
    maximumWeight?: CyclingMaximumWeight;
    minimumRecommendedAge?: CyclingMinimumRecommendedAge;
    modelNumber?: string;
    msrp?: number;
    numberOfSpeeds?: number;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    season?: string[];
    seatingCapacity?: number;
    shape?: string;
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sport?: string[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: CyclingSwatchImage[];
    tireDiameter?: CyclingTireDiameter;
    variantAttributeNames?: CyclingVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface CyclingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface CyclingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CyclingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CyclingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface CyclingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BicycleFrameSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface BicycleWheelDiameter {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface CyclingFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface CyclingHorsepower {
    measure?: number;
    unit?: HorsepowerUnit;
}
export declare enum HorsepowerUnit {
    HP = "HP"
}
export interface CyclingMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface CyclingMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface CyclingMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface CyclingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CyclingVariantAttributeName;
}
export declare enum CyclingVariantAttributeName {
    AssembledProductWeight = "assembledProductWeight",
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Dexterity = "dexterity",
    Material = "material",
    Shape = "shape",
    Size = "size",
    SportsLeague = "sportsLeague",
    SportsTeam = "sportsTeam"
}
export interface CyclingTireDiameter {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface DecorationsFavors {
    additionalProductAttributes?: DecorationsFavorsAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: DecorationsFavorsAssembledProductHeight;
    assembledProductLength?: DecorationsFavorsAssembledProductLength;
    assembledProductWeight?: DecorationsFavorsAssembledProductWeight;
    assembledProductWidth?: DecorationsFavorsAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    autographedBy?: string;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    diameter?: DecorationsFavorsDiameter;
    features?: string[];
    finish?: string;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    holidayLightingStyle?: string[];
    isAdultProduct?: MustShipAlone;
    isAnimated?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isInflatable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    lightBulbColor?: string;
    lightBulbType?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    numberOfLights?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: DecorationsFavorsSwatchImage[];
    theme?: string[];
    variantAttributeNames?: DecorationsFavorsVariantAttributeName[];
    variantGroupId?: string;
    watts?: DecorationsFavorsWatts;
}
export interface DecorationsFavorsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface DecorationsFavorsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface DecorationsFavorsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface DecorationsFavorsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface DecorationsFavorsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface DecorationsFavorsDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export interface DecorationsFavorsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: DecorationsFavorsVariantAttributeName;
}
export declare enum DecorationsFavorsVariantAttributeName {
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    LightBulbType = "lightBulbType",
    Material = "material",
    Occasion = "occasion",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam",
    Theme = "theme"
}
export interface DecorationsFavorsWatts {
    measure?: number;
    unit?: WattsUnit;
}
export declare enum WattsUnit {
    KW = "kW",
    W = "W"
}
export interface Electrical {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: ElectricalAdditionalProductAttribute[];
    americanWireGauge?: number;
    amps?: ElectricalAmps;
    assembledProductHeight?: ElectricalAssembledProductHeight;
    assembledProductLength?: ElectricalAssembledProductLength;
    assembledProductWeight?: ElectricalAssembledProductWeight;
    assembledProductWidth?: ElectricalAssembledProductWidth;
    athlete?: string[];
    baseColor?: string;
    baseFinish?: string;
    beamAngle?: ElectricalBeamAngle;
    beamSpread?: ElectricalBeamSpread;
    brightness?: ElectricalBrightness;
    character?: string[];
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    colorTemperature?: ColorTemperature;
    compatibleConduitSizes?: CompatibleConduitSize[];
    conductorMaterial?: string;
    count?: string;
    countPerPack?: number;
    decibelRating?: ElectricalDecibelRating;
    electricalBallastFactor?: number;
    estimatedEnergyCostPerYear?: EstimatedEnergyCostPerYear;
    features?: string[];
    finish?: string;
    globalBrandLicense?: string[];
    homeDecorStyle?: string;
    horsepower?: ElectricalHorsepower;
    impedance?: ElectricalImpedance;
    isDarkSkyCompliant?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isFireResistant?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRatedForOutdoorUse?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    lifespan?: string;
    lightBulbBaseType?: LightBulbBaseCode;
    lightBulbColor?: string;
    lightBulbShape?: LightBulbShape;
    lightBulbType?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumEnergySurgeRating?: string;
    maximumRange?: string;
    modelNumber?: string;
    mountType?: string[];
    msrp?: number;
    numberOfGangs?: number;
    numberOfLights?: number;
    numberOfPoles?: number;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    responseTime?: ElectricalResponseTime;
    shadeMaterial?: string;
    shadeStyle?: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: ElectricalSwatchImage[];
    variantAttributeNames?: ElectricalVariantAttributeName[];
    variantGroupId?: string;
    volts?: ElectricalVolt[];
    warrantyText?: string;
    warrantyURL?: string;
    watts?: ElectricalWatts;
}
export interface ElectricalAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ElectricalAmps {
    measure?: number;
    unit?: AmpsUnit;
}
export declare enum AmpsUnit {
    A = "A",
    MA = "mA"
}
export interface ElectricalAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectricalAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectricalAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ElectricalAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectricalBeamAngle {
    measure?: number;
    unit?: BeamAngleUnit;
}
export declare enum BeamAngleUnit {
    º = "\u00BA"
}
export interface ElectricalBeamSpread {
    measure?: number;
    unit?: BeamSpreadUnit;
}
export declare enum BeamSpreadUnit {
    Ft = "ft"
}
export interface ElectricalBrightness {
    measure?: number;
    unit?: BrightnessUnit;
}
export declare enum BrightnessUnit {
    LM = "lm"
}
export interface ColorTemperature {
    measure?: number;
    unit?: ColorTemperatureUnit;
}
export declare enum ColorTemperatureUnit {
    K = "K"
}
export interface CompatibleConduitSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ElectricalDecibelRating {
    measure?: number;
    unit?: DecibelRatingUnit;
}
export declare enum DecibelRatingUnit {
    DB = "dB"
}
export interface EstimatedEnergyCostPerYear {
    measure?: number;
    unit?: EstimatedEnergyCostPerYearUnit;
}
export declare enum EstimatedEnergyCostPerYearUnit {
    Usd = "USD"
}
export interface ElectricalHorsepower {
    measure?: number;
    unit?: HorsepowerUnit;
}
export interface ElectricalImpedance {
    measure?: string;
    unit?: ImpedanceUnit;
}
export declare enum ImpedanceUnit {
    Kolms = "kolms",
    Olms = "olms"
}
export declare enum LightBulbBaseCode {
    BA15D = "BA15d",
    BA15S = "BA15s",
    E10 = "E10",
    E11 = "E11",
    E12 = "E12",
    E14 = "E14",
    E17 = "E17",
    E26 = "E26",
    E27 = "E27",
    E39 = "E39",
    E40 = "E40",
    E5 = "E5",
    Ex39 = "EX39",
    G10Q = "G10q",
    G12 = "G12",
    G23 = "G-23",
    G232 = "G-23-2",
    G24D1 = "G24d-1",
    G24D2 = "G24d-2",
    G24D3 = "G24d-3",
    G24Q1 = "G24q-1",
    G24Q2 = "G24q-2",
    G24Q3 = "G24q-3",
    G24Q4 = "G24q-4",
    G24Q5 = "G24q-5",
    G4 = "G4",
    G9 = "G9",
    GX10Q4 = "GX10q4",
    GX32D2 = "GX32d-2",
    GX32D3 = "GX32d-3",
    Gu10 = "GU10",
    Gu24 = "GU24",
    Gu4 = "GU4",
    Gu53 = "GU5.3",
    Gu635 = "GU6.35",
    Gu8 = "GU8",
    Gx232 = "GX23-2",
    Gy635 = "GY6.35",
    Gy86 = "GY8.6",
    R7 = "R7",
    R7S = "R7s",
    S14S = "S14s",
    Sc = "SC",
    The2G11 = "2G11",
    The2G7 = "2G7",
    The2Gx13 = "2GX13",
    The2Gx7 = "2GX7"
}
export declare enum LightBulbShape {
    ALine = "A-Line",
    ALineSpiral = "A-Line Spiral",
    Bullet = "Bullet",
    Candle = "Candle",
    Circline = "Circline",
    Flame = "Flame",
    Flicker = "Flicker",
    GlobeMini = "Globe Mini",
    Linear = "Linear",
    Reflector = "Reflector",
    Spiral = "Spiral",
    Tubular = "Tubular",
    Twist = "Twist",
    UShape = "U-Shape"
}
export interface ElectricalResponseTime {
    measure?: number;
    unit?: MaximumShutterSpeedUnit;
}
export interface ElectricalSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ElectricalVariantAttributeName;
}
export declare enum ElectricalVariantAttributeName {
    Amps = "amps",
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    BaseColor = "baseColor",
    BaseFinish = "baseFinish",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    MountType = "mountType",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam",
    Volts = "volts",
    Watts = "watts"
}
export interface ElectricalVolt {
    measure?: number;
    unit?: VoltUnit;
}
export declare enum VoltUnit {
    KV = "kV",
    KVAC = "kVAC",
    KVDC = "kVDC",
    MV = "mV",
    V = "V",
    Vac = "VAC",
    Vdc = "VDC"
}
export interface ElectricalWatts {
    measure?: number;
    unit?: WattsUnit;
}
export interface ElectronicsAccessories {
    additionalProductAttributes?: ElectronicsAccessoriesAdditionalProductAttribute[];
    assembledProductHeight?: ElectronicsAccessoriesAssembledProductHeight;
    assembledProductLength?: ElectronicsAccessoriesAssembledProductLength;
    assembledProductWeight?: ElectronicsAccessoriesAssembledProductWeight;
    assembledProductWidth?: ElectronicsAccessoriesAssembledProductWidth;
    audioFeatures?: string[];
    audioPowerOutput?: string;
    cableLength?: ElectronicsAccessoriesCableLength;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    compatibleDevices?: string[];
    compatibleModels?: string[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    dataTransferRate?: string;
    edition?: string;
    features?: string[];
    hardDriveCapacity?: ElectronicsAccessoriesHardDriveCapacity;
    headphoneFeatures?: string[];
    headphoneStyle?: HeadphoneStyle;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumLoadWeight?: MaximumLoadWeight;
    maximumScreenSize?: MaximumScreenSize;
    memoryCardType?: string[];
    microphoneTechnology?: string;
    minimumScreenSize?: MinimumScreenSize;
    modelNumber?: string;
    mountingPattern?: string;
    movementDetection?: string;
    msrp?: number;
    numberOfKeys?: number;
    numberOfSpeakers?: number;
    opticalDrive?: string;
    peakAudioPowerCapacity?: ElectronicsAccessoriesPeakAudioPowerCapacity;
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recordableMediaFormats?: string[];
    resolution?: string;
    screenSize?: ElectronicsAccessoriesScreenSize;
    shortDescription: string;
    size?: string;
    swatchImages?: ElectronicsAccessoriesSwatchImage[];
    tvAndMonitorMountType?: string;
    variantAttributeNames?: ElectronicsAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface ElectronicsAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ElectronicsAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectronicsAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectronicsAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ElectronicsAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectronicsAccessoriesCableLength {
    measure?: number;
    unit?: CableLengthUnit;
}
export interface ElectronicsAccessoriesHardDriveCapacity {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export declare enum HeadphoneStyle {
    InEar = "In-Ear",
    OnEar = "On-Ear",
    OverEar = "Over-Ear"
}
export interface MaximumLoadWeight {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export declare enum MaximumLoadWeightUnit {
    LB = "lb"
}
export interface MaximumScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface MinimumScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ElectronicsAccessoriesPeakAudioPowerCapacity {
    measure?: number;
    unit?: WattsUnit;
}
export interface ElectronicsAccessoriesScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ElectronicsAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: IndigoSwatchVariantAttribute;
}
export declare enum IndigoSwatchVariantAttribute {
    CableLength = "cableLength",
    Color = "color",
    CompatibleModels = "compatibleModels",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    MountType = "mountType",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export declare enum ElectronicsAccessoriesVariantAttributeName {
    CableLength = "cableLength",
    Color = "color",
    CompatibleModels = "compatibleModels",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size",
    TvAndMonitorMountType = "tvAndMonitorMountType"
}
export interface ElectronicsCables {
    additionalProductAttributes?: ElectronicsCablesAdditionalProductAttribute[];
    cableLength?: ElectronicsCablesCableLength;
    color?: string[];
    compatibleDevices?: string[];
    connections?: string[];
    connectorFinish?: string;
    count?: string;
    countPerPack?: number;
    dataTransferRate?: string;
    features?: string[];
    globalBrandLicense?: string[];
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    msrp?: number;
    numberOfChannels?: string;
    numberOfTwistedPairsPerCable?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shortDescription: string;
    swatchImages?: ElectronicsCablesSwatchImage[];
    variantAttributeNames?: ElectronicsCablesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface ElectronicsCablesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ElectronicsCablesCableLength {
    measure?: number;
    unit?: CableLengthUnit;
}
export interface ElectronicsCablesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ElectronicsCablesVariantAttributeName;
}
export declare enum ElectronicsCablesVariantAttributeName {
    CableLength = "cableLength",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack"
}
export interface ElectronicsOther {
    additionalProductAttributes?: ElectronicsOtherAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: ElectronicsOtherAssembledProductHeight;
    assembledProductLength?: ElectronicsOtherAssembledProductLength;
    assembledProductWeight?: ElectronicsOtherAssembledProductWeight;
    assembledProductWidth?: ElectronicsOtherAssembledProductWidth;
    audioFeatures?: string[];
    audioPowerOutput?: string;
    babyMonitorType?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    dataTransferRate?: string;
    digitalAudioFileFormat?: string[];
    features?: string[];
    hardDriveCapacity?: ElectronicsOtherHardDriveCapacity;
    impedance?: ElectronicsOtherImpedance;
    inflexKitComponent?: MustShipAlone;
    isCordless?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isSmart?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    memoryCardType?: string[];
    microphoneTechnology?: string;
    modelNumber?: string;
    msrp?: number;
    numberOfChannels?: string;
    numberOfSpeakers?: number;
    peakAudioPowerCapacity?: ElectronicsOtherPeakAudioPowerCapacity;
    pieceCount?: number;
    platform?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    resolution?: string;
    shortDescription: string;
    size?: string;
    speakerDriver?: string;
    streamingServices?: string;
    supportedMediaFormats?: string;
    swatchImages?: ElectronicsOtherSwatchImage[];
    variantAttributeNames?: ElectronicsOtherVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface ElectronicsOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ElectronicsOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectronicsOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectronicsOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ElectronicsOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ElectronicsOtherHardDriveCapacity {
    measure?: number;
    unit?: HardDriveCapacityUnit;
}
export interface ElectronicsOtherImpedance {
    measure?: string;
    unit?: ImpedanceUnit;
}
export interface ElectronicsOtherPeakAudioPowerCapacity {
    measure?: number;
    unit?: WattsUnit;
}
export interface ElectronicsOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ElectronicsOtherVariantAttributeName;
}
export declare enum ElectronicsOtherVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Platform = "platform",
    Resolution = "resolution",
    Size = "size"
}
export interface FoodBeverage {
    additionalProductAttributes?: FoodBeverageAdditionalProductAttribute[];
    beefCut?: string;
    caffeineDesignation?: CaffeineDesignation;
    calories?: FoodBeverageCalories;
    caloriesFromFat?: FoodBeverageCaloriesFromFat;
    character?: string[];
    containerType?: string[];
    count?: string;
    countPerPack?: number;
    cuisine?: string[];
    dietaryMethod?: string[];
    dietType?: DietType;
    flavor?: string;
    foodAllergenStatements?: string[];
    foodForm?: string;
    foodPreparationTips?: string[];
    ingredients?: string;
    instructions?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: FoodBeverageLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    meal?: string;
    mealStyle?: string;
    msrp?: number;
    nutrientContentClaims?: string[];
    nutrientFootnote?: string;
    nutrients?: FoodBeverageNutrient[];
    poultryCut?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    puffedSnackType?: PuffedSnackType;
    releaseDate?: Date;
    safeHandlingInstructions?: string;
    servingSize?: string;
    servingsPerContainer?: number;
    shelfLife?: FoodBeverageShelfLife;
    shortDescription: string;
    size?: string;
    spiceLevel?: string;
    swatchImages?: FoodBeverageSwatchImage[];
    totalCarbohydrate?: FoodBeverageTotalCarbohydrate;
    totalCarbohydratePercentageDailyValue?: number;
    totalFat?: FoodBeverageTotalFat;
    totalFatPercentageDailyValue?: number;
    totalProtein?: FoodBeverageTotalProtein;
    totalProteinPercentageDailyValue?: number;
    variantAttributeNames?: FoodBeverageVariantAttributeName[];
    variantGroupId?: string;
}
export interface FoodBeverageAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export declare enum CaffeineDesignation {
    CaffeineAdded = "Caffeine Added",
    Decaffeinated = "Decaffeinated",
    NaturallyCaffeinated = "Naturally Caffeinated",
    NaturallyDecaffeinated = "Naturally Decaffeinated"
}
export interface FoodBeverageCalories {
    measure?: number;
    unit?: CaloriesUnit;
}
export interface FoodBeverageCaloriesFromFat {
    measure?: number;
    unit?: CaloriesUnit;
}
export declare enum DietType {
    The01Vegetarian = "01 - Vegetarian",
    The02Coeliac = "02 - Coeliac",
    The03Dietetic = "03 - Dietetic",
    The04Halal = "04 - Halal",
    The05Kosher = "05 - Kosher",
    The06Vegan = "06 - Vegan",
    The07AllNatural = "07 - All Natural",
    The08WithoutBeef = "08 - Without Beef",
    The09Organic = "09 - Organic",
    The10WithoutPork = "10 - Without Pork",
    The11BetterForYou = "11 - Better For You",
    The12FatFree = "12 - Fat Free",
    The13GlutenFree = "13 - Gluten Free",
    The14SugarFree = "14 - Sugar Free"
}
export interface FoodBeverageLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export interface FoodBeverageNutrient {
    nutrientAmount?: string;
    nutrientName?: string;
    nutrientPercentageDailyValue?: string;
}
export declare enum PuffedSnackType {
    MicrowavePopcorn = "Microwave Popcorn",
    PopcornKernel = "Popcorn Kernel",
    ReadyToEatPopcorn = "Ready to Eat Popcorn"
}
export interface FoodBeverageShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface FoodBeverageSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: FoodBeverageVariantAttributeName;
}
export declare enum FoodBeverageVariantAttributeName {
    Count = "count",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    Size = "size"
}
export interface FoodBeverageTotalCarbohydrate {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface FoodBeverageTotalFat {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface FoodBeverageTotalProtein {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface Footwear {
    activity?: string[];
    additionalProductAttributes?: FootwearAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    athlete?: string[];
    autographedBy?: string;
    bootShaftCircumference?: BootShaftCircumference[];
    bootShaftHeight?: BootShaftHeight[];
    bootShaftStyle?: string[];
    bootShaftWidthStyle?: string[];
    casualAndDressShoeType?: string;
    character?: string[];
    collection?: string;
    color: string[];
    colorCategory: ColorCategory[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    embellishmentType?: string[];
    fabricCareInstructions?: string[];
    fabricContent?: FootwearFabricContent[];
    features?: string[];
    footwearHeelStyle?: string;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    healthConcerns?: string[];
    heelDrop?: HeelDrop;
    heelHeight?: HeelHeight;
    insoleFeature?: string[];
    isOrthopedic?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterResistant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    material?: string[];
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    season?: string[];
    seasonCode?: SeasonCode;
    seasonYear?: number;
    secondaryMaterial?: string[];
    shoeCategory?: ShoeCategory;
    shoeClosure?: string;
    shoeSize: string;
    shoeSizeSystem?: ShoeSizeSystem;
    shoeSoleMaterial?: string;
    shoeStyle?: string;
    shoeWidth?: string;
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: FootwearSwatchImage[];
    toeStyle?: string;
    variantAttributeNames?: FootwearVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface FootwearAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BootShaftCircumference {
    measure?: number;
    unit?: BootShaftCircumferenceUnit;
}
export declare enum BootShaftCircumferenceUnit {
    CM = "cm",
    In = "in",
    Mm = "mm"
}
export interface BootShaftHeight {
    measure?: number;
    unit?: BootShaftCircumferenceUnit;
}
export interface FootwearFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface HeelDrop {
    measure?: number;
    unit?: BootShaftCircumferenceUnit;
}
export interface HeelHeight {
    measure?: number;
    unit?: HeelHeightUnit;
}
export declare enum HeelHeightUnit {
    In = "in",
    Mm = "mm"
}
export declare enum ShoeSizeSystem {
    EUInfant = "EU Infant",
    EUKidS = "EU Kid's",
    EUMenS = "EU Men's",
    EUWomenS = "EU Women's",
    EUYouth = "EU Youth",
    UKInfant = "UK Infant",
    UKKidS = "UK Kid's",
    UKMenS = "UK Men's",
    UKWomenS = "UK Women's",
    UKYouth = "UK Youth",
    USInfant = "US Infant",
    USKidS = "US Kid's",
    USMenS = "US Men's",
    USWomenS = "US Women's",
    USYouth = "US Youth"
}
export interface FootwearSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: FootwearVariantAttributeName;
}
export declare enum FootwearVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    HeelHeight = "heelHeight",
    Material = "material",
    Pattern = "pattern",
    ShoeSize = "shoeSize",
    ShoeWidth = "shoeWidth",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface FuelsLubricants {
    additionalProductAttributes?: FuelsLubricantsAdditionalProductAttribute[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    fluidOunces?: FuelsLubricantsFluidOunces;
    form?: string;
    fuelType?: string;
    instructions?: string;
    isBiodegradable?: MustShipAlone;
    isCombustible?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isFlammable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRefillable?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    msrp?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shelfLife?: FuelsLubricantsShelfLife;
    shortDescription: string;
    size?: string;
    swatchImages?: FuelsLubricantsSwatchImage[];
    systemOfMeasurement?: string;
    variantAttributeNames?: FuelsLubricantsVariantAttributeName[];
    variantGroupId?: string;
}
export interface FuelsLubricantsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface FuelsLubricantsFluidOunces {
    measure?: number;
    unit?: FluidOuncesSupplying100CaloriesUnit;
}
export interface FuelsLubricantsShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface FuelsLubricantsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: FuelsLubricantsVariantAttributeName;
}
export declare enum FuelsLubricantsVariantAttributeName {
    Count = "count",
    CountPerPack = "countPerPack",
    Size = "size"
}
export interface Funeral {
    additionalProductAttributes?: FuneralAdditionalProductAttribute[];
    assembledProductHeight?: FuneralAssembledProductHeight;
    assembledProductLength?: FuneralAssembledProductLength;
    assembledProductWeight?: FuneralAssembledProductWeight;
    assembledProductWidth?: FuneralAssembledProductWidth;
    assemblyInstructions?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    features?: string[];
    finish?: string;
    globalBrandLicense?: string[];
    isAssemblyRequired?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    swatchImages?: FuneralSwatchImage[];
    variantAttributeNames?: FuneralVariantAttributeName[];
    variantGroupId?: string;
}
export interface FuneralAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface FuneralAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface FuneralAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface FuneralAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface FuneralAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface FuneralSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: FuneralVariantAttributeName;
}
export declare enum FuneralVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Occasion = "occasion",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size"
}
export interface Furniture {
    accentColor?: string;
    additionalProductAttributes?: FurnitureAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: FurnitureAssembledProductHeight;
    assembledProductLength?: FurnitureAssembledProductLength;
    assembledProductWeight?: FurnitureAssembledProductWeight;
    assembledProductWidth?: FurnitureAssembledProductWidth;
    assemblyInstructions?: string;
    autographedBy?: string;
    baseColor?: string;
    baseFinish?: string;
    baseMaterial?: string;
    bedSize?: string;
    bedStyle?: string;
    character?: string[];
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    configuration?: string;
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    cushionColor?: string;
    diameter?: FurnitureDiameter;
    doorOpeningStyle?: string;
    doorStyle?: string;
    fabricCareInstructions?: string[];
    fabricColor?: string;
    fabricContent?: FurnitureFabricContent[];
    features?: string[];
    fillMaterial?: string[];
    finish?: string;
    frameColor?: string;
    frameMaterial?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    hardwareFinish?: string;
    headboardStyle?: string;
    homeDecorStyle?: string;
    inflexKitComponent?: MustShipAlone;
    isAntique?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isInflatable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    lightingFactsLabel?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    mattressFirmness?: string;
    mattressThickness?: MattressThickness;
    modelNumber?: string;
    mountType?: string[];
    msrp?: number;
    numberOfDrawers?: number;
    numberOfHooks?: number;
    numberOfPanels?: number;
    numberOfShelves?: number;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    pumpIncluded?: MustShipAlone;
    recommendedLocations?: string[];
    recommendedRooms?: string[];
    recommendedUses?: string[];
    seatBackHeight?: SeatBackHeight;
    seatBackStyle?: string;
    seatHeight?: FurnitureSeatHeight;
    seatingCapacity?: number;
    seatMaterial?: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    slatWidth?: FurnitureSlatWidth;
    sportsTeam?: string[];
    swatchImages?: FurnitureSwatchImage[];
    tableHeight?: TableHeight;
    theme?: string[];
    topDimensions?: string;
    topFinish?: string;
    topMaterial?: string;
    variantAttributeNames?: FurnitureVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface FurnitureAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface FurnitureAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface FurnitureAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface FurnitureAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface FurnitureAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface FurnitureDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export interface FurnitureFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface MattressThickness {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface SeatBackHeight {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface FurnitureSeatHeight {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface FurnitureSlatWidth {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface FurnitureSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: IndecentSwatchVariantAttribute;
}
export declare enum IndecentSwatchVariantAttribute {
    AssembledProductWidth = "assembledProductWidth",
    BaseColor = "baseColor",
    BaseFinish = "baseFinish",
    BedSize = "bedSize",
    Character = "character",
    Color = "color",
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    CushionColor = "cushionColor",
    Diameter = "diameter",
    Finish = "finish",
    Firmness = "Firmness",
    FrameColor = "frameColor",
    Material = "material",
    MattressFirmness = "mattressFirmness",
    MattressThickness = "mattressThickness",
    MountType = "mountType",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size"
}
export interface TableHeight {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export declare enum FurnitureVariantAttributeName {
    AssembledProductWidth = "assembledProductWidth",
    BaseColor = "baseColor",
    BaseFinish = "baseFinish",
    BedSize = "bedSize",
    Character = "character",
    Color = "color",
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    CushionColor = "cushionColor",
    Diameter = "diameter",
    Finish = "finish",
    FrameColor = "frameColor",
    Material = "material",
    MattressFirmness = "mattressFirmness",
    MattressThickness = "mattressThickness",
    MountType = "mountType",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface GardenPatio {
    additionalProductAttributes?: GardenPatioAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: GardenPatioAssembledProductHeight;
    assembledProductLength?: GardenPatioAssembledProductLength;
    assembledProductWeight?: GardenPatioAssembledProductWeight;
    assembledProductWidth?: GardenPatioAssembledProductWidth;
    assemblyInstructions?: string;
    baseMaterial?: string;
    capacity?: string;
    character?: string[];
    cleaningCareAndMaintenance?: string;
    clearingWidth?: ClearingWidth;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    coverageArea?: GardenPatioCoverageArea;
    cuttingWidth?: string;
    diameter?: GardenPatioDiameter;
    fabricContent?: GardenPatioFabricContent[];
    features?: string[];
    finish?: string;
    flooringMaterial?: string;
    flowRate?: GardenPatioFlowRate;
    frameMaterial?: string[];
    fuelType?: string;
    globalBrandLicense?: string[];
    hasAutomaticShutoff?: MustShipAlone;
    hasRadiantHeat?: MustShipAlone;
    homeDecorStyle?: string;
    inflexKitComponent?: MustShipAlone;
    installationType?: string;
    isAntique?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isBulk?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isTearResistant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    lightBulbColor?: string;
    lightBulbType?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumWeight?: GardenPatioMaximumWeight;
    minimumClearance?: MinimumClearance;
    minimumTemperature?: GardenPatioMinimumTemperature;
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    pieceCount?: number;
    plantCategory?: string;
    powerType?: string;
    productSecondaryImageURL?: string[];
    productVolume?: string;
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    season?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsTeam?: string[];
    sprayPatterns?: string;
    swatchImages?: GardenPatioSwatchImage[];
    theme?: string[];
    variantAttributeNames?: GardenPatioVariantAttributeName[];
    variantGroupId?: string;
    vaseIncluded?: MustShipAlone;
    volts?: GardenPatioVolt[];
    warrantyText?: string;
    warrantyURL?: string;
    watts?: GardenPatioWatts;
}
export interface GardenPatioAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface GardenPatioAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GardenPatioAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GardenPatioAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface GardenPatioAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ClearingWidth {
    measure?: number;
    unit?: ClearingWidthUnit;
}
export declare enum ClearingWidthUnit {
    CM = "cm",
    Ft = "ft",
    In = "in"
}
export interface GardenPatioCoverageArea {
    measure?: number;
    unit?: CoverageAreaUnit;
}
export interface GardenPatioDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export interface GardenPatioFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface GardenPatioFlowRate {
    measure?: number;
    unit?: FlowRateUnit;
}
export declare enum FlowRateUnit {
    Gpm = "gpm"
}
export interface GardenPatioMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface MinimumClearance {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface GardenPatioMinimumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export interface GardenPatioSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: HilariousSwatchVariantAttribute;
}
export declare enum HilariousSwatchVariantAttribute {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    Finish = "finish",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size"
}
export declare enum GardenPatioVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    Finish = "finish",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam",
    VaseIncluded = "vaseIncluded"
}
export interface GardenPatioVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface GardenPatioWatts {
    measure?: number;
    unit?: WattsUnit;
}
export interface GiftSupplyAwards {
    additionalProductAttributes?: GiftSupplyAwardsAdditionalProductAttribute[];
    assembledProductHeight?: GiftSupplyAwardsAssembledProductHeight;
    assembledProductLength?: GiftSupplyAwardsAssembledProductLength;
    assembledProductWeight?: GiftSupplyAwardsAssembledProductWeight;
    assembledProductWidth?: GiftSupplyAwardsAssembledProductWidth;
    assemblyInstructions?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    globalBrandLicense?: string[];
    isAssemblyRequired?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    pattern?: string[];
    productSecondaryImageURL?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: GiftSupplyAwardsSwatchImage[];
    theme?: string[];
    variantAttributeNames?: GiftSupplyAwardsVariantAttributeName[];
    variantGroupId?: string;
}
export interface GiftSupplyAwardsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface GiftSupplyAwardsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GiftSupplyAwardsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GiftSupplyAwardsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface GiftSupplyAwardsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GiftSupplyAwardsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: GiftSupplyAwardsVariantAttributeName;
}
export declare enum GiftSupplyAwardsVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Occasion = "occasion",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size",
    Theme = "theme"
}
export interface GrillsOutdoorCooking {
    additionalProductAttributes?: GrillsOutdoorCookingAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: GrillsOutdoorCookingAssembledProductHeight;
    assembledProductLength?: GrillsOutdoorCookingAssembledProductLength;
    assembledProductWeight?: GrillsOutdoorCookingAssembledProductWeight;
    assembledProductWidth?: GrillsOutdoorCookingAssembledProductWidth;
    assemblyInstructions?: string;
    btu?: number;
    capacity?: string;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    finish?: string;
    flavor?: string;
    flowRate?: GrillsOutdoorCookingFlowRate;
    frameMaterial?: string[];
    fuelType?: string;
    globalBrandLicense?: string[];
    hasAutomaticShutoff?: MustShipAlone;
    hasCharcoalBasket?: MustShipAlone;
    hasRadiantHeat?: MustShipAlone;
    hasSideShelf?: MustShipAlone;
    hasTankTray?: MustShipAlone;
    homeDecorStyle?: string;
    installationType?: string;
    isAssemblyRequired?: MustShipAlone;
    isBulk?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    lifespan?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumTemperature?: GrillsOutdoorCookingMaximumTemperature;
    maximumWeight?: GrillsOutdoorCookingMaximumWeight;
    minimumTemperature?: GrillsOutdoorCookingMinimumTemperature;
    modelNumber?: string;
    msrp?: number;
    numberOfBurners?: number;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    productVolume?: string;
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    shortDescription: string;
    sideBurnerSize?: SideBurnerSize;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: GrillsOutdoorCookingSwatchImage[];
    totalCookingArea?: TotalCookingArea;
    variantAttributeNames?: GrillsOutdoorCookingVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface GrillsOutdoorCookingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface GrillsOutdoorCookingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GrillsOutdoorCookingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GrillsOutdoorCookingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface GrillsOutdoorCookingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface GrillsOutdoorCookingFlowRate {
    measure?: number;
    unit?: FlowRateUnit;
}
export interface GrillsOutdoorCookingMaximumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export interface GrillsOutdoorCookingMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface GrillsOutdoorCookingMinimumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export interface SideBurnerSize {
    measure?: number;
    unit?: SideBurnerSizeUnit;
}
export declare enum SideBurnerSizeUnit {
    SqIn = "sq in"
}
export interface GrillsOutdoorCookingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: AmbitiousSwatchVariantAttribute;
}
export declare enum AmbitiousSwatchVariantAttribute {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface TotalCookingArea {
    measure?: number;
    unit?: SideBurnerSizeUnit;
}
export declare enum GrillsOutdoorCookingVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    HomeDecorStyle = "homeDecorStyle",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface Hardware {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: HardwareAdditionalProductAttribute[];
    alphanumericCharacter?: string;
    assembledProductHeight?: HardwareAssembledProductHeight;
    assembledProductLength?: HardwareAssembledProductLength;
    assembledProductWeight?: HardwareAssembledProductWeight;
    assembledProductWidth?: HardwareAssembledProductWidth;
    backsetSize?: BacksetSize;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    finish?: string;
    globalBrandLicense?: string[];
    grade?: string;
    homeDecorStyle?: string;
    isFireResistant?: MustShipAlone;
    isLockable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    lockingMechanism?: string;
    lockType?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumWeight?: HardwareMaximumWeight;
    modelNumber?: string;
    mountType?: string[];
    msrp?: number;
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: HardwareSwatchImage[];
    threadStandard?: string;
    variantAttributeNames?: HardwareVariantAttributeName[];
    variantGroupId?: string;
    volts?: HardwareVolt[];
    warrantyText?: string;
    warrantyURL?: string;
    workingLoadLimit?: number;
}
export interface HardwareAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface HardwareAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HardwareAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HardwareAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface HardwareAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface BacksetSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface HardwareMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface HardwareSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: CunningSwatchVariantAttribute;
}
export declare enum CunningSwatchVariantAttribute {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Grade = "grade",
    MountType = "mountType",
    Shape = "shape",
    Size = "size",
    WorkingLoadLimit = "workingLoadLimit"
}
export declare enum HardwareVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Grade = "grade",
    MountType = "mountType",
    Shape = "shape",
    Size = "size",
    Volts = "volts",
    WorkingLoadLimit = "workingLoadLimit"
}
export interface HardwareVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface HealthBeautyElectronics {
    additionalProductAttributes?: HealthBeautyElectronicsAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: HealthBeautyElectronicsAssembledProductHeight;
    assembledProductLength?: HealthBeautyElectronicsAssembledProductLength;
    assembledProductWeight?: HealthBeautyElectronicsAssembledProductWeight;
    assembledProductWidth?: HealthBeautyElectronicsAssembledProductWidth;
    bodyParts?: string[];
    color?: string[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    hairCareKeyBenefit?: HairCareKeyBenefit[];
    hairProductForm?: HairProductForm;
    hairType?: string;
    hasAutomaticShutoff?: MustShipAlone;
    ingredientPreference?: IngredientPreference[];
    instructions?: string;
    isCordless?: MustShipAlone;
    isDisposable?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReusable?: MustShipAlone;
    isTravelSize?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    makeupForm?: MakeupForm[];
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    msrp?: number;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shortDescription: string;
    size?: string;
    skinCareConcern?: string[];
    skinTone?: string;
    skinType?: string;
    swatchImages?: HealthBeautyElectronicsSwatchImage[];
    variantAttributeNames?: HealthBeautyElectronicsVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface HealthBeautyElectronicsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface HealthBeautyElectronicsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HealthBeautyElectronicsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HealthBeautyElectronicsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface HealthBeautyElectronicsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum IngredientPreference {
    CrueltyFree = "Cruelty-Free",
    LeapingBunny = "Leaping Bunny",
    PETABunny = "PETA Bunny",
    The100Organic = "100% Organic",
    Vegan = "Vegan"
}
export interface HealthBeautyElectronicsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: HealthBeautyElectronicsVariantAttributeName;
}
export declare enum HealthBeautyElectronicsVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Size = "size"
}
export interface HomeDecorKitchenOther {
    academicInstitution?: string;
    accentColor?: string;
    additionalProductAttributes?: HomeDecorKitchenOtherAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    artist?: string[];
    assembledProductHeight?: HomeDecorKitchenOtherAssembledProductHeight;
    assembledProductLength?: HomeDecorKitchenOtherAssembledProductLength;
    assembledProductWeight?: HomeDecorKitchenOtherAssembledProductWeight;
    assembledProductWidth?: HomeDecorKitchenOtherAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    baseColor?: string;
    baseFinish?: string;
    bedSize?: string;
    bedStyle?: string;
    capacity?: string;
    character?: string[];
    cleaningCareAndMaintenance?: string;
    clockNumberType?: string;
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    contaminantsRemoved?: string;
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    curtainLength?: CurtainLength;
    curtainPanelStyle?: string;
    diameter?: HomeDecorKitchenOtherDiameter;
    fabricCareInstructions?: string[];
    fabricColor?: string;
    fabricContent?: HomeDecorKitchenOtherFabricContent[];
    features?: string[];
    fillMaterial?: string[];
    finish?: string;
    frameColor?: string;
    framed?: MustShipAlone;
    frameMaterial?: string[];
    gender?: ArtCraftGender;
    globalBrandLicense?: string[];
    gramsSquareMeter?: number;
    homeDecorStyle?: string;
    inductionSafe?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isNonStick?: MustShipAlone;
    isPetFriendly?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isSet?: MustShipAlone;
    keyFeatures?: string[];
    lampType?: string[];
    lightingFactsLabel?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    meal?: string;
    mealStyle?: string;
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    orientation?: HomeDecorKitchenOtherOrientation;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedRooms?: string[];
    recommendedUses?: string[];
    rugSize?: string;
    rugStyle?: string[];
    scent?: string;
    serviceCount?: number;
    shadeMaterial?: string;
    shadeStyle?: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    slatWidth?: HomeDecorKitchenOtherSlatWidth;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: HomeDecorKitchenOtherSwatchImage[];
    theme?: string[];
    threadCount?: number;
    variantAttributeNames?: HomeDecorKitchenOtherVariantAttributeName[];
    variantGroupId?: string;
    volumeCapacity?: HomeDecorKitchenOtherVolumeCapacity;
    warrantyText?: string;
    warrantyURL?: string;
    windowTreatmentSheerness?: WindowTreatmentSheerness[];
}
export interface HomeDecorKitchenOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface HomeDecorKitchenOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HomeDecorKitchenOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HomeDecorKitchenOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface HomeDecorKitchenOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface CurtainLength {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface HomeDecorKitchenOtherDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export interface HomeDecorKitchenOtherFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export declare enum HomeDecorKitchenOtherOrientation {
    Square = "Square"
}
export interface HomeDecorKitchenOtherSlatWidth {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface HomeDecorKitchenOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: MagentaSwatchVariantAttribute;
}
export declare enum MagentaSwatchVariantAttribute {
    AcademicInstitution = "academicInstitution",
    AccentColor = "accentColor",
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    BaseColor = "baseColor",
    BaseFinish = "baseFinish",
    Capacity = "capacity",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    FabricColor = "fabricColor",
    FabricMaterialName = "fabricMaterialName",
    Finish = "finish",
    FrameColor = "frameColor",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Pattern = "pattern",
    Scent = "scent",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export declare enum HomeDecorKitchenOtherVariantAttributeName {
    AcademicInstitution = "academicInstitution",
    AccentColor = "accentColor",
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    BaseColor = "baseColor",
    BaseFinish = "baseFinish",
    BedSize = "bedSize",
    Capacity = "capacity",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    FabricColor = "fabricColor",
    FabricMaterialName = "fabricMaterialName",
    Finish = "finish",
    FrameColor = "frameColor",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Pattern = "pattern",
    Scent = "scent",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface HomeDecorKitchenOtherVolumeCapacity {
    measure?: number;
    unit?: VolumeCapacityUnit;
}
export declare enum VolumeCapacityUnit {
    CuCM = "cu cm",
    CuFt = "cu ft",
    CuIn = "cu in",
    FLOz = "fl oz",
    Gal = "gal",
    L = "L",
    Ml = "ml",
    Pt = "pt",
    Qt = "qt"
}
export declare enum WindowTreatmentSheerness {
    Blackout = "Blackout",
    EnergyEfficient = "Energy Efficient",
    LightFiltering = "Light Filtering",
    RoomDarkening = "Room Darkening",
    Sheer = "Sheer"
}
export interface HouseholdCleaningProductsSupplies {
    activeIngredients?: HouseholdCleaningProductsSuppliesActiveIngredient[];
    additionalProductAttributes?: HouseholdCleaningProductsSuppliesAdditionalProductAttribute[];
    assembledProductHeight?: HouseholdCleaningProductsSuppliesAssembledProductHeight;
    assembledProductLength?: HouseholdCleaningProductsSuppliesAssembledProductLength;
    assembledProductWeight?: HouseholdCleaningProductsSuppliesAssembledProductWeight;
    assembledProductWidth?: HouseholdCleaningProductsSuppliesAssembledProductWidth;
    assemblyInstructions?: string;
    bladeWidth?: HouseholdCleaningProductsSuppliesBladeWidth;
    bristleMaterial?: string;
    cleaningPath?: CleaningPath;
    color?: string[];
    colorCategory?: ColorCategory[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    fabricContent?: HouseholdCleaningProductsSuppliesFabricContent[];
    features?: string[];
    finish?: string;
    fluidOunces?: HouseholdCleaningProductsSuppliesFluidOunces;
    form?: string;
    handleLength?: HouseholdCleaningProductsSuppliesHandleLength;
    inactiveIngredients?: string[];
    ingredients?: string;
    instructions?: string;
    isAssemblyRequired?: MustShipAlone;
    isBiodegradable?: MustShipAlone;
    isCombustible?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isFlammable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRecyclable?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: HouseholdCleaningProductsSuppliesLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    numberOfSheets?: number;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedRooms?: string[];
    recommendedSurfaces?: string[];
    scent?: string;
    shape?: string;
    shelfLife?: HouseholdCleaningProductsSuppliesShelfLife;
    shortDescription: string;
    size?: string;
    swatchImages?: HouseholdCleaningProductsSuppliesSwatchImage[];
    variantAttributeNames?: HouseholdCleaningProductsSuppliesVariantAttributeName[];
    variantGroupId?: string;
    volts?: HouseholdCleaningProductsSuppliesVolt[];
}
export interface HouseholdCleaningProductsSuppliesActiveIngredient {
    activeIngredientName?: string;
    activeIngredientPercentage?: number;
}
export interface HouseholdCleaningProductsSuppliesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface HouseholdCleaningProductsSuppliesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HouseholdCleaningProductsSuppliesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HouseholdCleaningProductsSuppliesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface HouseholdCleaningProductsSuppliesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface HouseholdCleaningProductsSuppliesBladeWidth {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface CleaningPath {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface HouseholdCleaningProductsSuppliesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface HouseholdCleaningProductsSuppliesFluidOunces {
    measure?: number;
    unit?: FluidOuncesSupplying100CaloriesUnit;
}
export interface HouseholdCleaningProductsSuppliesHandleLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface HouseholdCleaningProductsSuppliesLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export interface HouseholdCleaningProductsSuppliesShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface HouseholdCleaningProductsSuppliesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: HouseholdCleaningProductsSuppliesVariantAttributeName;
}
export declare enum HouseholdCleaningProductsSuppliesVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Scent = "scent",
    Shape = "shape",
    Size = "size"
}
export interface HouseholdCleaningProductsSuppliesVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface InstrumentAccessories {
    additionalProductAttributes?: InstrumentAccessoriesAdditionalProductAttribute[];
    assembledProductHeight?: InstrumentAccessoriesAssembledProductHeight;
    assembledProductLength?: InstrumentAccessoriesAssembledProductLength;
    assembledProductWeight?: InstrumentAccessoriesAssembledProductWeight;
    assembledProductWidth?: InstrumentAccessoriesAssembledProductWidth;
    athlete?: string[];
    autographedBy?: string;
    batteryLife?: InstrumentAccessoriesBatteryLife;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    displayTechnology?: string;
    features?: string[];
    hasBluetooth?: MustShipAlone;
    ingredients?: string;
    inputsAndOutputs?: InstrumentAccessoriesInputsAndOutput[];
    instrument?: string[];
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRemoteControlIncluded?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: InstrumentAccessoriesSwatchImage[];
    variantAttributeNames?: InstrumentAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface InstrumentAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface InstrumentAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface InstrumentAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface InstrumentAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface InstrumentAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface InstrumentAccessoriesBatteryLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface InstrumentAccessoriesInputsAndOutput {
    inputOutputQuantity?: number;
    inputOutputType?: string;
}
export interface InstrumentAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: InstrumentAccessoriesVariantAttributeName;
}
export declare enum InstrumentAccessoriesVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Pattern = "pattern",
    SportsTeam = "sportsTeam"
}
export interface Jewelry {
    accentStone?: AryStoneType[];
    additionalProductAttributes?: JewelryAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    backFinding?: EarringBack;
    birthstone?: BirthstoneMonth;
    bodyJewelryStyle?: string;
    bodyParts?: string[];
    braceletCharmStyle?: string;
    braceletStyle?: BraceletStyle;
    carats?: JewelryCarats;
    certifyingAgent?: string;
    chainLength?: JewelryChainLength;
    chainPattern?: ChainPattern[];
    character?: string[];
    claspType?: ClaspType[];
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    diameter?: JewelryDiameter;
    diamondClarity?: DiamondClarity;
    diamondColor?: DiamondColor;
    diamondCut?: DiamondCut;
    earGaugeSize?: EarGaugeSize;
    earringStyle?: EarringStyle;
    gemstone?: AryStoneType;
    gemstoneShape?: PrimaryStoneShape;
    gender?: BabyClothingGender;
    isMadeFromRecycledMaterial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isResizable?: MustShipAlone;
    jewelrySetting?: JewelrySetting[];
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    metal?: MetalType;
    metalPurity?: string;
    modelNumber?: string;
    msrp?: number;
    necklaceStyle?: NecklaceStyle;
    numberOfGemstones?: number;
    occasion?: string[];
    pearlType?: string[];
    personalRelationship?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recycledMaterialContent?: JewelryRecycledMaterialContent[];
    religion?: Religion;
    ringSize?: number;
    ringStyle?: string[];
    seasonCode?: SeasonCode;
    seasonYear?: number;
    secondaryStoneType?: AryStoneType;
    shape?: string;
    shortDescription: string;
    size?: string;
    sizePerPearl?: SizePerPearl;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    stoneCreationMethod?: string;
    stoneTreatment?: string;
    style?: string;
    swatchImages?: JewelrySwatchImage[];
    theme?: string[];
    totalDiamondWeight?: JewelryTotalDiamondWeight;
    variantAttributeNames?: JewelryVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export declare enum AryStoneType {
    Alexandrite = "Alexandrite",
    Amber = "Amber",
    Amethyst = "Amethyst",
    Ametrine = "Ametrine",
    Aquamarine = "Aquamarine",
    Beryl = "Beryl",
    Carnelian = "Carnelian",
    CatSEye = "Cat's Eye",
    Chalcedony = "Chalcedony",
    ChromeDiopside = "Chrome Diopside",
    Citrine = "Citrine",
    Coral = "Coral",
    Crystal = "Crystal",
    CubicZirconia = "Cubic Zirconia",
    Diamond = "Diamond",
    Emerald = "Emerald",
    Garnet = "Garnet",
    Iolite = "Iolite",
    Jade = "Jade",
    Kunzite = "Kunzite",
    LapisLazuli = "Lapis Lazuli",
    Malachite = "Malachite",
    Moissanite = "Moissanite",
    Moonstone = "Moonstone",
    Morganite = "Morganite",
    MotherOfPearl = "Mother of Pearl",
    Onyx = "Onyx",
    Opal = "Opal",
    OtherStone = "Other Stone",
    Pearl = "Pearl",
    Peridot = "Peridot",
    Quartz = "Quartz",
    Rhodolite = "Rhodolite",
    Rhodonite = "Rhodonite",
    RoseQuartz = "Rose Quartz",
    Ruby = "Ruby",
    Sapphire = "Sapphire",
    Sodalite = "Sodalite",
    Spinel = "Spinel",
    Sunstone = "Sunstone",
    Tanzanite = "Tanzanite",
    TigerSEye = "Tiger's Eye",
    Topaz = "Topaz",
    Tourmaline = "Tourmaline",
    Tsavorite = "Tsavorite",
    Turquoise = "Turquoise",
    WhiteSapphire = "White Sapphire",
    Zircon = "Zircon"
}
export interface JewelryAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export declare enum EarringBack {
    ClickTop = "Click Top",
    ClipOn = "Clip-On",
    Clutchless = "Clutchless",
    ContinuousHoop = "Continuous Hoop",
    Endless = "Endless",
    EuroWire = "Euro Wire",
    Fishhook = "Fishhook",
    FrenchWire = "French Wire",
    Hinged = "Hinged",
    Hoop = "Hoop",
    LaPousette = "La Pousette",
    LatchBack = "Latch Back",
    LeverBack = "Lever Back",
    OmegaBack = "Omega Back",
    Other = "Other",
    PostWithFrictionBack = "Post With Friction Back",
    PostWithSnapDown = "Post With Snap Down",
    PushBack = "Push Back",
    ScrewBack = "Screw Back",
    ShepherdsHook = "Shepherds Hook",
    ThreadThrough = "Thread Through"
}
export declare enum BirthstoneMonth {
    April = "April",
    August = "August",
    December = "December",
    February = "February",
    January = "January",
    July = "July",
    June = "June",
    March = "March",
    May = "May",
    November = "November",
    October = "October",
    September = "September"
}
export declare enum BraceletStyle {
    Bangle = "Bangle",
    Bead = "Bead",
    Cable = "Cable",
    CapeCod = "Cape Cod",
    Chain = "Chain",
    Charm = "Charm",
    Cord = "Cord",
    Cuff = "Cuff",
    IDBracelets = "ID Bracelets",
    Link = "Link",
    MultiStrand = "Multi-Strand",
    Other = "Other",
    Stackable = "Stackable",
    Stretch = "Stretch",
    TennisBracelets = "Tennis Bracelets",
    Wrap = "Wrap"
}
export interface JewelryCarats {
    measure?: number;
    unit?: CaratsUnit;
}
export declare enum CaratsUnit {
    CT = "ct"
}
export interface JewelryChainLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum ChainPattern {
    Anchor = "Anchor",
    Ball = "Ball",
    Bar = "Bar",
    Basketweave = "Basketweave",
    Bead = "Bead",
    Belcher = "Belcher",
    BeveledHerringbone = "Beveled Herringbone",
    Bismark = "Bismark",
    BostonLink = "Boston Link",
    BowTieFigaro = "Bow-Tie Figaro",
    Box = "Box",
    Byzantine = "Byzantine",
    CChain = "C-Chain",
    Cable = "Cable",
    CableWire = "Cable Wire",
    Cascade = "Cascade",
    Cobra = "Cobra",
    Cord = "Cord",
    Coreana = "Coreana",
    Crisscross = "Crisscross",
    CubanLink = "Cuban Link",
    Curb = "Curb",
    DiamondCutFigaro = "Diamond Cut Figaro",
    DoubleCable = "Double Cable",
    DoubleCurb = "Double Curb",
    DrawFlatCable = "Draw Flat Cable",
    ElongatedCable = "Elongated Cable",
    FancyDoubleLink = "Fancy Double Link",
    Figaro = "Figaro",
    FlatFigaro = "Flat Figaro",
    FlatGooseneck = "Flat Gooseneck",
    Franco = "Franco",
    FrenchRope = "French Rope",
    HalfRoundGooseneck = "Half Round Gooseneck",
    Heart = "Heart",
    Herringbone = "Herringbone",
    Hexagon = "Hexagon",
    HollowMariner = "Hollow Mariner",
    Lace = "Lace",
    Link = "Link",
    Mariner = "Mariner",
    Mesh = "Mesh",
    Mirror = "Mirror",
    Omega = "Omega",
    OpenCable = "Open Cable",
    Other = "Other",
    OvalCurb = "Oval Curb",
    Palma = "Palma",
    ParallelCurb = "Parallel Curb",
    Popcorn = "Popcorn",
    Puzzle = "Puzzle",
    Raspberry = "Raspberry",
    Rolo = "Rolo",
    Rope = "Rope",
    RoundOmega = "Round Omega",
    SANMarco = "San Marco",
    Serpentine = "Serpentine",
    SideBySide = "Side-by-Side",
    Singapore = "Singapore",
    Snake = "Snake",
    StockingMesh = "Stocking Mesh",
    Strand = "Strand",
    Tornado = "Tornado",
    Track = "Track",
    TripleRope = "Triple Rope",
    TwisterRope = "Twister Rope",
    TwisterSerpentine = "Twister Serpentine",
    Wheat = "Wheat",
    WireCable = "Wire Cable"
}
export declare enum ClaspType {
    Ball = "Ball",
    BarrelClasp = "Barrel Clasp",
    Box = "Box",
    Buckle = "Buckle",
    ButtonEnd = "Button-End",
    ButtonFly = "Button Fly",
    ButtonToggle = "Button Toggle",
    Concealed = "Concealed",
    DRing = "D Ring",
    Elastic = "Elastic",
    Fishhook = "Fishhook",
    FlatSolidBuckle = "Flat Solid Buckle",
    FoldOver = "Fold Over",
    HiddenSafetyClasp = "Hidden Safety Clasp",
    HookEyeClasp = "Hook & Eye Clasp",
    HookLoopClasp = "Hook & Loop Clasp",
    InvisibleDoubleLocking = "Invisible Double-Locking",
    LobsterClaw = "Lobster Claw",
    MagneticClasp = "Magnetic Clasp",
    NoClasp = "No Clasp",
    Other = "Other",
    PushButton = "Push Button",
    SHook = "S Hook",
    Screw = "Screw",
    SideLock = "Side Lock",
    Snaps = "Snaps",
    SpringRing = "Spring Ring",
    Toggle = "Toggle"
}
export interface JewelryDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export declare enum DiamondClarity {
    FL = "FL",
    I1 = "I1",
    I2 = "I2",
    I3 = "I3",
    If = "IF",
    Other = "Other",
    Si1 = "SI1",
    Si2 = "SI2",
    Vs1 = "VS1",
    Vs2 = "VS2",
    Vvs1 = "VVS1",
    Vvs2 = "VVS2"
}
export declare enum DiamondColor {
    D = "D",
    DE = "D-E",
    DF = "D-F",
    E = "E",
    EF = "E-F",
    F = "F",
    FG = "F-G",
    G = "G",
    GH = "G-H",
    H = "H",
    HI = "H-I",
    I = "I",
    IJ = "I-J",
    J = "J",
    JK = "J-K",
    K = "K",
    KL = "K-L",
    L = "L",
    LM = "L-M",
    M = "M",
    NR = "N-R",
    Other = "Other",
    SZ = "S-Z"
}
export declare enum DiamondCut {
    AsscherCut = "Asscher cut",
    BaguetteCut = "Baguette cut",
    CushionCut = "Cushion cut",
    EmeraldCut = "Emerald cut",
    FancyCut = "Fancy cut",
    HeartCut = "Heart cut",
    MarquiseCut = "Marquise cut",
    OtherCut = "Other cut",
    OvalCut = "Oval cut",
    PearCut = "Pear cut",
    PrincessCut = "Princess cut",
    RadiantCut = "Radiant cut",
    RoundBrilliantCut = "Round Brilliant cut",
    SquareCut = "Square cut"
}
export interface EarGaugeSize {
    measure?: number;
    unit?: HeelHeightUnit;
}
export declare enum EarringStyle {
    Chandelier = "Chandelier",
    Dangling = "Dangling",
    Drop = "Drop",
    FakeGauge = "Fake Gauge",
    Hoop = "Hoop",
    Stud = "Stud",
    Teardrop = "Teardrop",
    Threader = "Threader"
}
export declare enum PrimaryStoneShape {
    Asscher = "Asscher",
    Baguette = "Baguette",
    Cushion = "Cushion",
    Emerald = "Emerald",
    Heart = "Heart",
    Marquise = "Marquise",
    Oval = "Oval",
    Pear = "Pear",
    Princess = "Princess",
    Radiant = "Radiant",
    Round = "Round"
}
export declare enum JewelrySetting {
    Bar = "bar",
    Basket = "basket",
    BeadSet = "bead-set",
    Bezel = "bezel",
    Bypass = "bypass",
    Cathedral = "cathedral",
    Channel = "channel",
    ClassicSolitaire = "classic solitaire",
    Cluster = "cluster",
    Cocktail = "cocktail",
    Designer = "designer",
    EternityBand = "eternity band",
    FlatTop = "flat top",
    Flush = "flush",
    Freedom = "freedom",
    Guard = "guard",
    Gypsy = "gypsy",
    HalfBezel = "half bezel",
    Halo = "halo",
    HandWired = "hand-wired",
    Illusion = "illusion",
    Invisible = "invisible",
    Other = "other",
    Pave = "pave",
    Prongs = "prongs",
    Semimount = "semimount",
    SharedProng = "shared prong",
    SideStone = "side stone",
    Solitaire = "solitaire",
    Stackable = "stackable",
    Strung = "strung",
    TensionMount = "tension mount",
    The2Prong = "2-prong",
    The3Prong = "3-prong",
    The3Stone = "3-stone",
    The4Prong = "4-prong",
    The6Prong = "6-prong",
    Trellis = "trellis",
    TricolorRolling = "tricolor rolling",
    TwoToneFreedom = "two-tone freedom",
    VProng = "v-prong",
    Waterfall = "waterfall",
    Wrap = "wrap"
}
export declare enum NecklaceStyle {
    Bib = "Bib",
    Cascade = "Cascade",
    Chain = "Chain",
    Choker = "Choker",
    Collar = "Collar",
    Initial = "Initial",
    Lariat = "Lariat",
    Locket = "Locket",
    MultiStrand = "Multi Strand",
    Other = "Other",
    Pendant = "Pendant",
    SentimentSymbols = "Sentiment & Symbols",
    SingleStrand = "Single Strand",
    Solitaire = "Solitaire",
    YNecklace = "Y-necklace"
}
export interface JewelryRecycledMaterialContent {
    percentageOfRecycledMaterial?: number;
    recycledMaterial?: string;
}
export declare enum Religion {
    Buddhism = "Buddhism",
    Christianity = "Christianity",
    Hinduism = "Hinduism",
    Islam = "Islam",
    Judaism = "Judaism",
    Other = "Other"
}
export interface SizePerPearl {
    measure?: number;
    unit?: FocalLengthUnit;
}
export interface JewelrySwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: JewelryVariantAttributeName;
}
export declare enum JewelryVariantAttributeName {
    Birthstone = "birthstone",
    Carats = "carats",
    ChainLength = "chainLength",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    Gemstone = "gemstone",
    Metal = "metal",
    MetalPurity = "metalPurity",
    RingSize = "ringSize",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam",
    Style = "style"
}
export interface JewelryTotalDiamondWeight {
    measure?: number;
    unit?: CaratsUnit;
}
export interface LandVehicles {
    acceleration?: string;
    additionalProductAttributes?: LandVehiclesAdditionalProductAttribute[];
    assembledProductHeight?: LandVehiclesAssembledProductHeight;
    assembledProductLength?: LandVehiclesAssembledProductLength;
    assembledProductWeight?: LandVehiclesAssembledProductWeight;
    assembledProductWidth?: LandVehiclesAssembledProductWidth;
    averageFuelConsumption?: LandVehiclesAverageFuelConsumption;
    boreStroke?: string;
    color?: string[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    compressionRatio?: string;
    coolingSystem?: string;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    curbWeight?: CurbWeight;
    drivetrain?: string;
    engineDisplacement?: LandVehiclesEngineDisplacement;
    engineModel?: string;
    fabricContent?: LandVehiclesFabricContent[];
    features?: string[];
    frontBrakes?: string;
    frontSuspension?: string;
    frontTires?: string;
    frontWheels?: string;
    fuelCapacity?: LandVehiclesFuelCapacity;
    fuelRequirement?: string;
    fuelSystem?: string;
    inductionSystem?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumEnginePower?: LandVehiclesMaximumEnginePower;
    modelNumber?: string;
    msrp?: number;
    powertrain?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    rearBrakes?: string;
    rearSuspension?: string;
    rearTires?: string;
    rearWheels?: string;
    seatHeight?: LandVehiclesSeatHeight;
    seatingCapacity?: number;
    shortDescription: string;
    submodel?: string;
    swatchImages?: LandVehiclesSwatchImage[];
    topSpeed?: LandVehiclesTopSpeed;
    torque?: string;
    towingCapacity?: TowingCapacity;
    transmissionDesignation?: string;
    variantAttributeNames?: LandVehiclesVariantAttributeName[];
    variantGroupId?: string;
    vehicleMake?: string;
    vehicleModel?: string;
    vehicleType?: string;
    vehicleYear?: number;
    warrantyText?: string;
    warrantyURL?: string;
    wheelbase?: Wheelbase;
}
export interface LandVehiclesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface LandVehiclesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LandVehiclesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LandVehiclesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface LandVehiclesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LandVehiclesAverageFuelConsumption {
    measure?: number;
    unit?: AverageFuelConsumptionUnit;
}
export declare enum AverageFuelConsumptionUnit {
    Mpg = "mpg"
}
export interface CurbWeight {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export interface LandVehiclesEngineDisplacement {
    measure?: number;
    unit?: EngineDisplacementUnit;
}
export declare enum EngineDisplacementUnit {
    Cc = "cc",
    Cid = "CID"
}
export interface LandVehiclesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface LandVehiclesFuelCapacity {
    measure?: number;
    unit?: FuelCapacityUnit;
}
export declare enum FuelCapacityUnit {
    Gal = "gal",
    L = "L"
}
export interface LandVehiclesMaximumEnginePower {
    measure?: number;
    unit?: MaximumEnginePowerUnit;
}
export declare enum MaximumEnginePowerUnit {
    HP = "hp",
    KW = "kW"
}
export interface LandVehiclesSeatHeight {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface LandVehiclesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: LandVehiclesVariantAttributeName;
}
export declare enum LandVehiclesVariantAttributeName {
    Color = "color",
    Count = "count",
    EngineModel = "engineModel",
    VehicleMake = "vehicleMake",
    VehicleModel = "vehicleModel",
    VehicleYear = "vehicleYear"
}
export interface LandVehiclesTopSpeed {
    measure?: number;
    unit?: TopSpeedUnit;
}
export declare enum TopSpeedUnit {
    Kph = "kph",
    Mph = "mph"
}
export interface TowingCapacity {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export interface Wheelbase {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LargeAppliances {
    additionalProductAttributes?: LargeAppliancesAdditionalProductAttribute[];
    assembledProductHeight?: LargeAppliancesAssembledProductHeight;
    assembledProductLength?: LargeAppliancesAssembledProductLength;
    assembledProductWeight?: LargeAppliancesAssembledProductWeight;
    assembledProductWidth?: LargeAppliancesAssembledProductWidth;
    assemblyInstructions?: string;
    btu?: number;
    capacity?: string;
    cleaningCareAndMaintenance?: string;
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    cordLength?: LargeAppliancesCordLength;
    energyGuideLabel?: string;
    features?: string[];
    finish?: string;
    fuelType?: string;
    hasAutomaticShutoff?: MustShipAlone;
    hasCfl?: MustShipAlone;
    homeDecorStyle?: string;
    isAssemblyRequired?: MustShipAlone;
    isEnergyStarCertified?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRemoteControlIncluded?: MustShipAlone;
    isSet?: MustShipAlone;
    isSmart?: MustShipAlone;
    keyFeatures?: string[];
    lightingFactsLabel?: string;
    loadPosition?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRoomSize?: MaximumRoomSize;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedRooms?: string[];
    recommendedUses?: string[];
    runTime?: RunTime;
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: LargeAppliancesSwatchImage[];
    variantAttributeNames?: LargeAppliancesVariantAttributeName[];
    variantGroupId?: string;
    volts?: LargeAppliancesVolt[];
    warrantyText?: string;
    warrantyURL?: string;
    watts?: LargeAppliancesWatts;
}
export interface LargeAppliancesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface LargeAppliancesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LargeAppliancesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LargeAppliancesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface LargeAppliancesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface LargeAppliancesCordLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MaximumRoomSize {
    measure?: number;
    unit?: CoverageAreaUnit;
}
export interface RunTime {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface LargeAppliancesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: LargeAppliancesVariantAttributeName;
}
export declare enum LargeAppliancesVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Capacity = "capacity",
    Color = "color",
    Finish = "finish",
    HomeDecorStyle = "homeDecorStyle",
    Material = "material",
    Pattern = "pattern",
    Shape = "shape",
    Size = "size"
}
export interface LargeAppliancesVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface LargeAppliancesWatts {
    measure?: number;
    unit?: WattsUnit;
}
export interface MedicalAidsEquipment {
    additionalProductAttributes?: MedicalAidsEquipmentAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: MedicalAidsEquipmentAssembledProductHeight;
    assembledProductLength?: MedicalAidsEquipmentAssembledProductLength;
    assembledProductWeight?: MedicalAidsEquipmentAssembledProductWeight;
    assembledProductWidth?: MedicalAidsEquipmentAssembledProductWidth;
    bodyParts?: string[];
    cleaningCareAndMaintenance?: string;
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    count?: string;
    countPerPack?: number;
    diameter?: MedicalAidsEquipmentDiameter;
    driveSystem?: string;
    fabricCareInstructions?: string[];
    fabricContent?: MedicalAidsEquipmentFabricContent[];
    features?: string[];
    gender?: BabyClothingGender;
    healthConcerns?: string[];
    isDisposable?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isInflatable?: MustShipAlone;
    isLatexFree?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReusable?: MustShipAlone;
    isSet?: MustShipAlone;
    isTravelSize?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumWeight?: MedicalAidsEquipmentMaximumWeight;
    medicineStrength?: string;
    minimumWeight?: MedicalAidsEquipmentMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: MedicalAidsEquipmentSwatchImage[];
    variantAttributeNames?: MedicalAidsEquipmentVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface MedicalAidsEquipmentAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface MedicalAidsEquipmentAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MedicalAidsEquipmentAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MedicalAidsEquipmentAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface MedicalAidsEquipmentAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MedicalAidsEquipmentDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export interface MedicalAidsEquipmentFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface MedicalAidsEquipmentMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface MedicalAidsEquipmentMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface MedicalAidsEquipmentSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: MedicalAidsEquipmentVariantAttributeName;
}
export declare enum MedicalAidsEquipmentVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Diameter = "diameter",
    MedicineStrength = "medicineStrength",
    Shape = "shape",
    Size = "size"
}
export interface MedicineSupplements {
    activeIngredients?: MedicineSupplementsActiveIngredient[];
    activityStage?: ActivityStage[];
    additionalProductAttributes?: MedicineSupplementsAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    bodyParts?: string[];
    calories?: MedicineSupplementsCalories;
    color?: string[];
    countPerPack?: number;
    dietaryMethod?: string[];
    dosage?: string;
    drugActiveInactiveIngredientsImage?: string;
    drugDosageInstructionsImage?: string;
    flavor?: string;
    form?: string;
    gender?: BabyClothingGender;
    healthConcerns?: string[];
    inactiveIngredients?: string[];
    ingredients?: string;
    instructions?: string;
    isControlledSubstance?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    labelImage: MedicineSupplementsLabelImage[];
    mainImageUrl: string;
    manufacturer: string;
    medicineStrength?: string;
    msrp?: number;
    nationalDrugCode?: string;
    nutrientContentClaims?: string[];
    nutrients?: Supplement[];
    primaryIngredient?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    servingSize?: string;
    servingsPerContainer?: number;
    shelfLife?: MedicineSupplementsShelfLife;
    shortDescription: string;
    size?: string;
    stopUseIndications?: string[];
    sugarPerServing?: number;
    supplementActiveInactiveIngredientsImage?: string;
    supplementDosageInstructionsImage?: string;
    swatchImages?: MedicineSupplementsSwatchImage[];
    symptoms?: string;
    totalCarbohydrate?: MedicineSupplementsTotalCarbohydrate;
    totalFat?: MedicineSupplementsTotalFat;
    totalProtein?: MedicineSupplementsTotalProtein;
    variantAttributeNames?: MedicineSupplementsVariantAttributeName[];
    variantGroupId?: string;
}
export interface MedicineSupplementsActiveIngredient {
    activeIngredientName?: string;
    activeIngredientPercentage?: number;
}
export declare enum ActivityStage {
    IntraWorkout = "Intra-Workout",
    PostWorkout = "Post-Workout",
    PreWorkout = "Pre-Workout"
}
export interface MedicineSupplementsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface MedicineSupplementsCalories {
    measure?: number;
    unit?: CaloriesUnit;
}
export interface MedicineSupplementsLabelImage {
    labelImageContains: LabelImageContains;
    labelImageURL: string;
}
export interface Supplement {
    nutrientAmount?: string;
    nutrientName?: string;
    nutrientPercentageDailyValue?: string;
}
export interface MedicineSupplementsShelfLife {
    measure?: number;
    unit?: ShelfLifeUnit;
}
export interface MedicineSupplementsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: FriskySwatchVariantAttribute;
}
export declare enum FriskySwatchVariantAttribute {
    Count = "count",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    MedicineStrength = "medicineStrength",
    Size = "size"
}
export interface MedicineSupplementsTotalCarbohydrate {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface MedicineSupplementsTotalFat {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export interface MedicineSupplementsTotalProtein {
    measure?: number;
    unit?: TotalCarbohydrateUnit;
}
export declare enum MedicineSupplementsVariantAttributeName {
    Color = "color",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    MedicineStrength = "medicineStrength",
    Size = "size"
}
export interface Movies {
    actors?: string[];
    additionalProductAttributes?: MoviesAdditionalProductAttribute[];
    additionalVariantAttributeNames?: string[];
    aspectRatio?: string;
    awardsWon?: string[];
    director?: string;
    dubbedLanguages?: string[];
    duration?: Duration;
    edition?: string;
    hasSubtitles?: MustShipAlone;
    isDubbed?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    mainImageUrl: string;
    movieGenre?: string;
    movieSubgenre?: string;
    mpaaRating?: MPAARating;
    numberInSeries?: string;
    numberOfDiscs?: number;
    originalLanguages?: string[];
    physicalMediaFormat?: MoviesPhysicalMediaFormat[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    ratingReason?: string;
    screenwriter?: string;
    seriesTitle?: string;
    shortDescription: string;
    studioProductionCompany?: string;
    subtitledLanguages?: string[];
    swatchImages?: MoviesSwatchImage[];
    theatricalReleaseDate?: Date;
    title?: string;
    variantAttributeNames?: FoodBeverageVariantAttributeName[];
    variantGroupId?: string;
}
export interface MoviesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface Duration {
    measure?: number;
    unit?: DurationUnit;
}
export declare enum DurationUnit {
    Min = "min"
}
export declare enum MPAARating {
    G = "G",
    Nc17 = "NC-17",
    NotRated = "Not Rated",
    PG = "PG",
    PG13 = "PG-13",
    R = "R"
}
export declare enum MoviesPhysicalMediaFormat {
    BluRay = "Blu-Ray",
    CD = "CD",
    CassetteTape = "Cassette Tape",
    DVD = "DVD",
    Digital = "Digital",
    DigitalHD = "Digital HD",
    Lp = "LP",
    MiniDVTape = "miniDV Tape",
    PrintedMedia = "Printed Media",
    The3DBluRay = "3D Blu-ray",
    The4KUltraHD = "4K Ultra HD",
    The8TrackTape = "8-Track Tape",
    USBStick = "USB stick",
    VHSTape = "VHS Tape"
}
export interface MoviesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: string;
}
export interface Music {
    additionalProductAttributes?: MusicAdditionalProductAttribute[];
    autographedBy?: string;
    awardsWon?: string[];
    character?: string[];
    digitalAudioFileFormat?: string[];
    edition?: string;
    hasParentalAdvisoryLabel?: MustShipAlone;
    isEdited?: MustShipAlone;
    isEnhanced?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    movieSubgenre?: string;
    musicGenre?: string;
    musicProducer?: string;
    musicReleaseType?: string;
    musicSubGenre?: string;
    numberInSeries?: string;
    numberOfDiscs?: number;
    numberOfTracks?: number;
    originalLanguages?: string[];
    parentalAdvisoryLabelURL?: string[];
    performer?: string[];
    physicalMediaFormat?: MoviesPhysicalMediaFormat[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    ratingReason?: string;
    recordLabel?: string;
    releaseDate?: Date;
    seriesTitle?: string;
    shortDescription: string;
    songwriter?: string;
    swatchImages?: MusicSwatchImage[];
    title?: string;
    trackListings?: TrackListing[];
    variantAttributeNames?: FoodBeverageVariantAttributeName[];
    variantGroupId?: string;
}
export interface MusicAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface MusicSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: string;
}
export interface TrackListing {
    trackDuration?: string;
    trackName?: string;
    trackNumber?: number;
}
export interface MusicCasesBags {
    additionalProductAttributes?: MusicCasesBagsAdditionalProductAttribute[];
    assembledProductHeight?: MusicCasesBagsAssembledProductHeight;
    assembledProductLength?: MusicCasesBagsAssembledProductLength;
    assembledProductWeight?: MusicCasesBagsAssembledProductWeight;
    assembledProductWidth?: MusicCasesBagsAssembledProductWidth;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    fabricCareInstructions?: string[];
    fabricContent?: MusicCasesBagsFabricContent[];
    features?: string[];
    hardOrSoftCase?: HardOrSoftCase;
    instrument?: string[];
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: MusicCasesBagsSwatchImage[];
    variantAttributeNames?: MusicCasesBagsVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface MusicCasesBagsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface MusicCasesBagsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MusicCasesBagsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MusicCasesBagsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface MusicCasesBagsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MusicCasesBagsFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface MusicCasesBagsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: MusicCasesBagsVariantAttributeName;
}
export declare enum MusicCasesBagsVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Shape = "shape"
}
export interface MusicalInstruments {
    additionalProductAttributes?: MusicalInstrumentsAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: MusicalInstrumentsAssembledProductHeight;
    assembledProductLength?: MusicalInstrumentsAssembledProductLength;
    assembledProductWeight?: MusicalInstrumentsAssembledProductWeight;
    assembledProductWidth?: MusicalInstrumentsAssembledProductWidth;
    audioPowerOutput?: string;
    batteryLife?: MusicalInstrumentsBatteryLife;
    color?: string[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    displayTechnology?: string;
    drumSetCymbalType?: DrumSetCymbalType[];
    features?: string[];
    finish?: string;
    guitarType?: GuitarType;
    hasBluetooth?: MustShipAlone;
    hasIntegratedSpeakers?: MustShipAlone;
    inputsAndOutputs?: MusicalInstrumentsInputsAndOutput[];
    instrument?: string[];
    isCollectible?: MustShipAlone;
    isElectric?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isSet?: MustShipAlone;
    karaokeMachineType?: KaraokeMachineType;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    microphoneIncluded?: MustShipAlone;
    modelNumber?: string;
    msrp?: number;
    musicalInstrumentFamily?: string;
    numberOfKeys?: number;
    numberOfStrings?: number;
    orientation?: MusicalInstrumentsOrientation;
    pattern?: string[];
    percussionInstrumentType?: string[];
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    saxophoneType?: SaxophoneType;
    shortDescription: string;
    skillLevel?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    soundKey?: SoundKey[];
    sportsTeam?: string[];
    swatchImages?: MusicalInstrumentsSwatchImage[];
    variantAttributeNames?: InstrumentAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface MusicalInstrumentsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface MusicalInstrumentsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MusicalInstrumentsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MusicalInstrumentsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface MusicalInstrumentsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MusicalInstrumentsBatteryLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export declare enum DrumSetCymbalType {
    AcousticCymbals = "Acoustic Cymbals",
    BellCymbals = "Bell Cymbals",
    ChinaCymbals = "China Cymbals",
    ClashCymbals = "Clash Cymbals",
    CrashCymbals = "Crash Cymbals",
    EffectCymbals = "Effect Cymbals",
    FingerCymbals = "Finger Cymbals",
    GongCymbals = "Gong Cymbals",
    HiHatCymbals = "Hi-Hat Cymbals",
    OrchestralCymbals = "Orchestral Cymbals",
    RideCymbals = "Ride Cymbals",
    SplashCymbals = "Splash Cymbals",
    SwishCymbals = "Swish Cymbals"
}
export declare enum GuitarType {
    Acoustic = "Acoustic",
    AcousticElectric = "Acoustic/Electric",
    Bass = "Bass",
    Classical = "Classical",
    Electric = "Electric",
    Nylon = "Nylon",
    Ukulele = "Ukulele"
}
export interface MusicalInstrumentsInputsAndOutput {
    inputOutputQuantity?: number;
    inputOutputType?: string;
}
export declare enum KaraokeMachineType {
    HandheldMicrophone = "Handheld Microphone",
    StandAlone = "Stand Alone",
    System = "System"
}
export declare enum MusicalInstrumentsOrientation {
    Horizontal = "Horizontal",
    Left = "Left",
    Right = "Right",
    Vertical = "Vertical"
}
export declare enum SaxophoneType {
    AltoSaxophones = "Alto Saxophones",
    BaritoneSaxophones = "Baritone Saxophones",
    BassSaxophones = "Bass Saxophones",
    SopraninoSaxophones = "Sopranino Saxophones",
    SopranoSaxophones = "Soprano Saxophones",
    TenorSaxophones = "Tenor Saxophones"
}
export declare enum SoundKey {
    Bb = "Bb",
    BbFDouble = "Bb/F Double",
    BbHighF = "Bb/High F",
    C = "C",
    Eb = "Eb",
    F = "F",
    FBb = "F/Bb",
    FBbFAlto = "F/Bb/F Alto"
}
export interface MusicalInstrumentsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: InstrumentAccessoriesVariantAttributeName;
}
export interface Office {
    additionalProductAttributes?: OfficeAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: OfficeAssembledProductHeight;
    assembledProductLength?: OfficeAssembledProductLength;
    assembledProductWeight?: OfficeAssembledProductWeight;
    assembledProductWidth?: OfficeAssembledProductWidth;
    brightness?: OfficeBrightness;
    calendarFormat?: string;
    calendarTerm?: CalendarTerm;
    capacity?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleDevices?: string[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    dexterity?: string;
    envelopeSize?: string;
    finish?: string;
    globalBrandLicense?: string[];
    holeSize?: HoleSize;
    hpprintercartridgeNumber?: string[];
    inkColor?: string[];
    isAntiglare?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isLined?: MustShipAlone;
    isMagnetic?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRefillable?: MustShipAlone;
    isRetractable?: MustShipAlone;
    isTearResistant?: MustShipAlone;
    keyFeatures?: string[];
    lightingFactsLabel?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    numberOfSheets?: number;
    occasion?: string[];
    overallExpansion?: OverallExpansion;
    paperClipSize?: PaperClipSize;
    paperSize?: string[];
    pattern?: string[];
    pencilLeadDiameter?: PencilLeadDiameter;
    penPointSize?: PenPointSize;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    shredderCutStyles?: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    swatchImages?: OfficeSwatchImage[];
    systemOfMeasurement?: string;
    tabColor?: string;
    tabCut?: TabCut;
    theme?: string[];
    variantAttributeNames?: OfficeVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    year?: number;
}
export interface OfficeAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface OfficeAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OfficeAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OfficeAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface OfficeAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OfficeBrightness {
    measure?: number;
    unit?: BrightnessUnit;
}
export interface CalendarTerm {
    measure?: number;
    unit?: CalendarTermUnit;
}
export declare enum CalendarTermUnit {
    Months = "months"
}
export interface HoleSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface OverallExpansion {
    measure?: number;
    unit?: OverallExpansionUnit;
}
export declare enum OverallExpansionUnit {
    Inches = "inches"
}
export declare enum PaperClipSize {
    Jumbo = "Jumbo",
    No1 = "No. 1",
    No2 = "No. 2",
    No3 = "No. 3"
}
export interface PenPointSize {
    measure?: number;
    unit?: FocalLengthUnit;
}
export declare enum PencilLeadDiameter {
    The03Mm = "0.3mm",
    The04Mm = "0.4mm",
    The05Mm = "0.5mm",
    The07Mm = "0.7mm",
    The09Mm = "0.9mm",
    The2Mm = "2mm",
    The315Mm = "3.15mm",
    The3Mm = "3mm",
    The56Mm = "5.6mm",
    The5Mm = "5mm"
}
export interface OfficeSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: OfficeVariantAttributeName;
}
export declare enum OfficeVariantAttributeName {
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    EnvelopeSize = "envelopeSize",
    Material = "material",
    NumberOfSheets = "numberOfSheets",
    PaperSize = "paperSize",
    Shape = "shape",
    Size = "size"
}
export declare enum TabCut {
    The12Cut = "1/2 cut",
    The13Cut = "1/3 cut",
    The15Cut = "1/5 cut",
    The25CutRightOfCenter = "2/5 cut - right of center",
    The25CutRightPosition = "2/5 cut - right position",
    Undercut = "undercut"
}
export interface Optical {
    additionalProductAttributes?: OpticalAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: OpticalAssembledProductHeight;
    assembledProductLength?: OpticalAssembledProductLength;
    assembledProductWeight?: OpticalAssembledProductWeight;
    assembledProductWidth?: OpticalAssembledProductWidth;
    athlete?: string[];
    character?: string[];
    cleaningCareAndMaintenance?: string;
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    count?: string;
    countPerPack?: number;
    eyewearFrameSize?: string;
    eyewearFrameStyle?: string;
    eyewearLensFeature?: string[];
    eyewearRimStyle?: EyewearRim;
    features?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    hasAdaptiveLenses?: MustShipAlone;
    isPolarized?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isScratchResistant?: MustShipAlone;
    isSet?: MustShipAlone;
    keyFeatures?: string[];
    lensMaterial?: string;
    lensTint?: string;
    lensType?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    sunglassesStyle?: string;
    swatchImages?: OpticalSwatchImage[];
    uvRating?: number;
    variantAttributeNames?: OpticalVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface OpticalAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface OpticalAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OpticalAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OpticalAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface OpticalAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum EyewearRim {
    FullRim = "Full-Rim",
    HalfRim = "Half-Rim",
    Rimless = "Rimless",
    SemiRimless = "Semi-Rimless"
}
export interface OpticalSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: OpticalVariantAttributeName;
}
export declare enum OpticalVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface Optics {
    additionalProductAttributes?: OpticsAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    assembledProductHeight?: OpticsAssembledProductHeight;
    assembledProductLength?: OpticsAssembledProductLength;
    assembledProductWeight?: OpticsAssembledProductWeight;
    assembledProductWidth?: OpticsAssembledProductWidth;
    assemblyInstructions?: string;
    attachmentStyle?: string;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    dexterity?: string;
    digitalZoom?: string;
    displayResolution?: string[];
    displayTechnology?: string;
    features?: string[];
    fieldOfView?: string;
    focalRatio?: string;
    focusType?: string[];
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    hasDovetailBarSystem?: MustShipAlone;
    hasLcdScreen?: MustShipAlone;
    hasMemoryCardSlot?: MustShipAlone;
    hasNightVision?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isFogResistant?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isLockable?: MustShipAlone;
    isMulticoated?: MustShipAlone;
    isParfocal?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    keyFeatures?: string[];
    lensCoating?: string;
    lensDiameter?: OpticsLensDiameter;
    lockType?: string;
    magnification?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: OpticsMaximumRecommendedAge;
    minimumRecommendedAge?: OpticsMinimumRecommendedAge;
    modelNumber?: string;
    msrp?: number;
    operatingTemperature?: OperatingTemperature;
    opticalZoom?: string;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    screenSize?: OpticsScreenSize;
    sensorResolution?: string;
    shortDescription: string;
    size?: string;
    sport?: string[];
    swatchImages?: OpticsSwatchImage[];
    variantAttributeNames?: OpticsVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface OpticsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface OpticsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OpticsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OpticsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface OpticsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OpticsLensDiameter {
    measure?: number;
    unit?: FocalLengthUnit;
}
export interface OpticsMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface OpticsMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface OperatingTemperature {
    measure?: number;
    unit?: OperatingTemperatureUnit;
}
export declare enum OperatingTemperatureUnit {
    ºC = "\u00BAC",
    ºF = "\u00BAF"
}
export interface OpticsScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface OpticsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: OpticsVariantAttributeName;
}
export declare enum OpticsVariantAttributeName {
    AssembledProductWeight = "assembledProductWeight",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Dexterity = "dexterity",
    Material = "material",
    Size = "size"
}
export interface Other {
    additionalProductAttributes?: OtherAdditionalProductAttribute[];
    assembledProductHeight?: OtherAssembledProductHeight;
    assembledProductLength?: OtherAssembledProductLength;
    assembledProductWeight?: OtherAssembledProductWeight;
    assembledProductWidth?: OtherAssembledProductWidth;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    finish?: string;
    gender?: BabyClothingGender;
    ingredients?: string;
    isFoldable?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRetractable?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: OtherSwatchImage[];
    systemOfMeasurement?: string;
    variantAttributeNames?: OtherVariantAttributeName[];
    variantGroupId?: string;
}
export interface OtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface OtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface OtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface OtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: OtherVariantAttributeName;
}
export declare enum OtherVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Shape = "shape",
    Size = "size"
}
export interface PhotoAccessories {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: PhotoAccessoriesAdditionalProductAttribute[];
    assembledProductHeight?: PhotoAccessoriesAssembledProductHeight;
    assembledProductLength?: PhotoAccessoriesAssembledProductLength;
    assembledProductWeight?: PhotoAccessoriesAssembledProductWeight;
    assembledProductWidth?: PhotoAccessoriesAssembledProductWidth;
    assemblyInstructions?: string;
    capacity?: string;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleBrands?: string[];
    compatibleDevices?: string[];
    connections?: string[];
    count?: string;
    countPerPack?: number;
    displayTechnology?: string;
    features?: string[];
    globalBrandLicense?: string[];
    inputsAndOutputs?: PhotoAccessoriesInputsAndOutput[];
    isAssemblyRequired?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    lightBulbType?: string;
    lightOutput?: LightOutput;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    memoryCardType?: string[];
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    recordableMediaFormats?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: PhotoAccessoriesSwatchImage[];
    variantAttributeNames?: PhotoAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    volts?: PhotoAccessoriesVolt[];
    warrantyText?: string;
    warrantyURL?: string;
    watts?: PhotoAccessoriesWatts;
    wirelessTechnologies?: string[];
}
export interface PhotoAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface PhotoAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PhotoAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PhotoAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface PhotoAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PhotoAccessoriesInputsAndOutput {
    inputOutputQuantity?: number;
    inputOutputType?: string;
}
export interface LightOutput {
    measure?: number;
    unit?: BrightnessUnit;
}
export interface PhotoAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: PhotoAccessoriesVariantAttributeName;
}
export declare enum PhotoAccessoriesVariantAttributeName {
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    Material = "material",
    Shape = "shape",
    Size = "size"
}
export interface PhotoAccessoriesVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface PhotoAccessoriesWatts {
    measure?: number;
    unit?: WattsUnit;
}
export interface PlumbingHVAC {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: PlumbingHVACAdditionalProductAttribute[];
    assembledProductHeight?: PlumbingHVACAssembledProductHeight;
    assembledProductLength?: PlumbingHVACAssembledProductLength;
    assembledProductWeight?: PlumbingHVACAssembledProductWeight;
    assembledProductWidth?: PlumbingHVACAssembledProductWidth;
    ceeTier?: CEETier;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    contaminantsRemoved?: string;
    count?: string;
    countPerPack?: number;
    coverageArea?: PlumbingHVACCoverageArea;
    faucetDrillings?: string;
    faucetHandleDesign?: string;
    features?: string[];
    finish?: string;
    fuelType?: string;
    gallonsPerFlush?: GallonsPerFlush;
    gallonsPerMinute?: GallonsPerMinute;
    globalBrandLicense?: string[];
    hardwareFinish?: string;
    hasCeeCertification?: MustShipAlone;
    homeDecorStyle?: string;
    horsepower?: PlumbingHVACHorsepower;
    humidificationOutputPerDay?: string;
    isFireResistant?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    mervRating?: string;
    modelNumber?: string;
    msrp?: number;
    numberOfBlades?: number;
    pieceCount?: number;
    pintsOfMoistureRemovedPerDay?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    roughInDistance?: RoughInDistance;
    shape?: string;
    shortDescription: string;
    size?: string;
    sprayPatterns?: string;
    swatchImages?: PlumbingHVACSwatchImage[];
    variantAttributeNames?: PlumbingHVACVariantAttributeName[];
    variantGroupId?: string;
    volts?: PlumbingHVACVolt[];
    volumeCapacity?: PlumbingHVACVolumeCapacity;
    warrantyText?: string;
    warrantyURL?: string;
    watts?: PlumbingHVACWatts;
}
export interface PlumbingHVACAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface PlumbingHVACAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PlumbingHVACAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PlumbingHVACAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface PlumbingHVACAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum CEETier {
    CEETierI = "CEE Tier I",
    CEETierII = "CEE Tier II",
    CEETierIII = "CEE Tier III"
}
export interface PlumbingHVACCoverageArea {
    measure?: number;
    unit?: CoverageAreaUnit;
}
export interface GallonsPerFlush {
    measure?: number;
    unit?: GallonsPerFlushUnit;
}
export declare enum GallonsPerFlushUnit {
    Gal = "gal"
}
export interface GallonsPerMinute {
    measure?: number;
    unit?: GallonsPerFlushUnit;
}
export interface PlumbingHVACHorsepower {
    measure?: number;
    unit?: HorsepowerUnit;
}
export interface RoughInDistance {
    measure?: string;
    unit?: RoughInDistanceUnit;
}
export interface PlumbingHVACSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: PlumbingHVACVariantAttributeName;
}
export declare enum PlumbingHVACVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    GallonsPerMinute = "gallonsPerMinute",
    Shape = "shape",
    Size = "size",
    Volts = "volts",
    Watts = "watts"
}
export interface PlumbingHVACVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface PlumbingHVACVolumeCapacity {
    measure?: number;
    unit?: VolumeCapacityUnit;
}
export interface PlumbingHVACWatts {
    measure?: number;
    unit?: WattsUnit;
}
export interface PrintersScannersImaging {
    additionalProductAttributes?: PrintersScannersImagingAdditionalProductAttribute[];
    assembledProductHeight?: PrintersScannersImagingAssembledProductHeight;
    assembledProductLength?: PrintersScannersImagingAssembledProductLength;
    assembledProductWeight?: PrintersScannersImagingAssembledProductWeight;
    assembledProductWidth?: PrintersScannersImagingAssembledProductWidth;
    color?: string[];
    colorPagesPerMinute?: number;
    connections?: string[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    has3dCapabilities?: MustShipAlone;
    hasAutomaticDocumentFeeder?: MustShipAlone;
    hasAutomaticTwoSidedPrinting?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumDocumentSize?: string;
    maximumPrintResolution?: MaximumPrintResolution;
    maximumScannerResolution?: MaximumScannerResolution;
    memoryCardType?: string[];
    modelNumber?: string;
    monochromeColor?: MonochromeColor;
    monochromePagesPerMinute?: number;
    msrp?: number;
    printingTechnology?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    resolution?: string;
    shortDescription: string;
    swatchImages?: PrintersScannersImagingSwatchImage[];
    variantAttributeNames?: PrintersScannersImagingVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface PrintersScannersImagingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface PrintersScannersImagingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PrintersScannersImagingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface PrintersScannersImagingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface PrintersScannersImagingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface MaximumPrintResolution {
    measure?: number;
    unit?: MaximumPrintResolutionUnit;
}
export declare enum MaximumPrintResolutionUnit {
    DPI = "dpi"
}
export interface MaximumScannerResolution {
    measure?: number;
    unit?: MaximumPrintResolutionUnit;
}
export declare enum MonochromeColor {
    Color = "Color",
    Monochrome = "Monochrome"
}
export interface PrintersScannersImagingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: MischievousSwatchVariantAttribute;
}
export declare enum MischievousSwatchVariantAttribute {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Resolution = "resolution",
    Size = "size"
}
export declare enum PrintersScannersImagingVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Resolution = "resolution"
}
export interface SafetyEmergency {
    additionalProductAttributes?: SafetyEmergencyAdditionalProductAttribute[];
    assembledProductHeight?: SafetyEmergencyAssembledProductHeight;
    assembledProductLength?: SafetyEmergencyAssembledProductLength;
    assembledProductWeight?: SafetyEmergencyAssembledProductWeight;
    assembledProductWidth?: SafetyEmergencyAssembledProductWidth;
    assemblyInstructions?: string;
    color?: string[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    fireExtinguisherClasses?: FireExtinguisherClass[];
    fluidOunces?: SafetyEmergencyFluidOunces;
    form?: string;
    handleLength?: SafetyEmergencyHandleLength;
    ingredients?: string;
    instructions?: string;
    isAssemblyRequired?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRefillable?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    msrp?: number;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedSurfaces?: string[];
    recommendedUses?: string[];
    shortDescription: string;
    size?: string;
    swatchImages?: SafetyEmergencySwatchImage[];
    variantAttributeNames?: HealthBeautyElectronicsVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    workingPressure?: WorkingPressure;
}
export interface SafetyEmergencyAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface SafetyEmergencyAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SafetyEmergencyAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SafetyEmergencyAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface SafetyEmergencyAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum FireExtinguisherClass {
    A = "A",
    B = "B",
    C = "C",
    D = "D",
    K = "K"
}
export interface SafetyEmergencyFluidOunces {
    measure?: number;
    unit?: FluidOuncesSupplying100CaloriesUnit;
}
export interface SafetyEmergencyHandleLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface SafetyEmergencySwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: HealthBeautyElectronicsVariantAttributeName;
}
export interface WorkingPressure {
    measure?: number;
    unit?: WorkingPressureUnit;
}
export declare enum WorkingPressureUnit {
    Bar = "Bar",
    Pa = "Pa",
    Psi = "psi"
}
export interface Software {
    additionalProductAttributes?: SoftwareAdditionalProductAttribute[];
    count?: string;
    countPerPack?: number;
    digitalFileFormat?: string[];
    educationalFocus?: string[];
    features?: string[];
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    msrp?: number;
    numberOfUsers?: number;
    operatingSystem?: string[];
    physicalMediaFormat?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    releaseDate?: Date;
    requiredPeripherals?: string;
    shortDescription: string;
    softwareCategory?: string[];
    swatchImages?: SoftwareSwatchImage[];
    systemRequirements?: string[];
    variantAttributeNames?: SoftwareVariantAttributeName[];
    variantGroupId?: string;
    version?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface SoftwareAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface SoftwareSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: BraggadociousSwatchVariantAttribute;
}
export declare enum BraggadociousSwatchVariantAttribute {
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    DigitalFileFormat = "digitalFileFormat",
    Edition = "edition",
    OperatingSystem = "operatingSystem",
    PhysicalMediaFormat = "physicalMediaFormat",
    Platform = "platform",
    Size = "size",
    Version = "version"
}
export declare enum SoftwareVariantAttributeName {
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    DigitalFileFormat = "digitalFileFormat",
    OperatingSystem = "operatingSystem",
    PhysicalMediaFormat = "physicalMediaFormat",
    Version = "version"
}
export interface SoundRecording {
    additionalProductAttributes?: SoundRecordingAdditionalProductAttribute[];
    assembledProductHeight?: SoundRecordingAssembledProductHeight;
    assembledProductLength?: SoundRecordingAssembledProductLength;
    assembledProductWeight?: SoundRecordingAssembledProductWeight;
    assembledProductWidth?: SoundRecordingAssembledProductWidth;
    audioPowerOutput?: string;
    batteryLife?: SoundRecordingBatteryLife;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    equalizerControl?: string;
    features?: string[];
    hasBluetooth?: MustShipAlone;
    hasIntegratedSpeakers?: MustShipAlone;
    impedance?: SoundRecordingImpedance;
    inputsAndOutputs?: SoundRecordingInputsAndOutput[];
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRemoteControlIncluded?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    microphoneTechnology?: string;
    modelNumber?: string;
    msrp?: number;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    shortDescription: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    swatchImages?: SoundRecordingSwatchImage[];
    variantAttributeNames?: SoundRecordingVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface SoundRecordingAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface SoundRecordingAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SoundRecordingAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SoundRecordingAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface SoundRecordingAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SoundRecordingBatteryLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface SoundRecordingImpedance {
    measure?: string;
    unit?: ImpedanceUnit;
}
export interface SoundRecordingInputsAndOutput {
    inputOutputQuantity?: number;
    inputOutputType?: string;
}
export interface SoundRecordingSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SoundRecordingVariantAttributeName;
}
export declare enum SoundRecordingVariantAttributeName {
    AudioPowerOutput = "audioPowerOutput",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material"
}
export interface SportRecreationOther {
    additionalProductAttributes?: SportRecreationOtherAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    AirGunPowerType?: AirGunPowerType;
    animalType?: string;
    assembledProductHeight?: SportRecreationOtherAssembledProductHeight;
    assembledProductLength?: SportRecreationOtherAssembledProductLength;
    assembledProductWeight?: SportRecreationOtherAssembledProductWeight;
    assembledProductWidth?: SportRecreationOtherAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    autographedBy?: string;
    ballCoreMaterial?: string[];
    basketballSize?: string;
    batDrop?: string;
    bladeType?: string;
    capacity?: string;
    character?: string[];
    cleaningCareAndMaintenance?: string;
    clothingSize?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compatibleDevices?: string[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    dexterity?: string;
    driveSystem?: string;
    fabricCareInstructions?: string[];
    fabricContent?: SportRecreationOtherFabricContent[];
    features?: string[];
    finish?: string;
    fishingLinePoundTest?: number;
    fishingLocation?: string;
    fitnessGoal?: string;
    footballSize?: string;
    gender?: BabyClothingGender;
    globalBrandLicense?: string[];
    golfClubShaftFlex?: string;
    golfClubShaftType?: string;
    hasAutomaticShutoff?: MustShipAlone;
    horsepower?: SportRecreationOtherHorsepower;
    inflexKitComponent?: MustShipAlone;
    insulationType?: InsulationType;
    isAssemblyRequired?: MustShipAlone;
    isCollectible?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isMemorabilia?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isSpaceSaving?: MustShipAlone;
    isTearResistant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    isWeatherResistant?: MustShipAlone;
    isWheeled?: MustShipAlone;
    keyFeatures?: string[];
    loft?: string;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumIncline?: number;
    maximumRecommendedAge?: SportRecreationOtherMaximumRecommendedAge;
    maximumWeight?: SportRecreationOtherMaximumWeight;
    minimumRecommendedAge?: SportRecreationOtherMinimumRecommendedAge;
    minimumTemperature?: SportRecreationOtherMinimumTemperature;
    modelNumber?: string;
    msrp?: number;
    pattern?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedUses?: string[];
    rValue?: number;
    season?: string[];
    seatingCapacity?: number;
    shaftLength?: string;
    shaftMaterial?: string[];
    shape?: string;
    shoeSize?: string;
    shortDescription: string;
    size?: string;
    sleepingBagSize?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    soccerBallSize?: string;
    sport?: string[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    strideLength?: number;
    swatchImages?: SportRecreationOtherSwatchImage[];
    tentType?: string;
    tireDiameter?: SportRecreationOtherTireDiameter;
    variantAttributeNames?: SportRecreationOtherVariantAttributeName[];
    variantGroupId?: string;
    velocity?: Velocity;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export declare enum AirGunPowerType {
    C02 = "C02",
    GasPiston = "Gas Piston",
    PrechargedPneumatic = "Precharged Pneumatic",
    PumpAction = "Pump Action",
    Spring = "Spring"
}
export interface SportRecreationOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface SportRecreationOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SportRecreationOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SportRecreationOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface SportRecreationOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface SportRecreationOtherFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface SportRecreationOtherHorsepower {
    measure?: number;
    unit?: HorsepowerUnit;
}
export declare enum InsulationType {
    Down = "Down",
    Synthetic = "Synthetic"
}
export interface SportRecreationOtherMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface SportRecreationOtherMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface SportRecreationOtherMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface SportRecreationOtherMinimumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export interface SportRecreationOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SportRecreationOtherVariantAttributeName;
}
export declare enum SportRecreationOtherVariantAttributeName {
    AssembledProductWeight = "assembledProductWeight",
    Capacity = "capacity",
    ClothingSize = "clothingSize",
    Color = "color",
    CompatibleDevices = "compatibleDevices",
    Count = "count",
    CountPerPack = "countPerPack",
    Dexterity = "dexterity",
    GolfClubShaftFlex = "golfClubShaftFlex",
    GolfClubShaftType = "golfClubShaftType",
    Loft = "loft",
    Material = "material",
    MinimumTemperature = "minimumTemperature",
    ShaftLength = "shaftLength",
    ShaftMaterial = "shaftMaterial",
    Shape = "shape",
    ShoeSize = "shoeSize",
    Size = "size",
    SportsLeague = "sportsLeague",
    SportsTeam = "sportsTeam"
}
export interface SportRecreationOtherTireDiameter {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface Velocity {
    measure?: number;
    unit?: VelocityUnit;
}
export declare enum VelocityUnit {
    FtS = "ft/s"
}
export interface Storage {
    additionalProductAttributes?: StorageAdditionalProductAttribute[];
    assembledProductHeight?: StorageAssembledProductHeight;
    assembledProductLength?: StorageAssembledProductLength;
    assembledProductWeight?: StorageAssembledProductWeight;
    assembledProductWidth?: StorageAssembledProductWidth;
    assemblyInstructions?: string;
    capacity?: string;
    collection?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    drawerDimensions?: string;
    drawerPosition?: string;
    fabricCareInstructions?: string[];
    fabricContent?: StorageFabricContent[];
    features?: string[];
    finish?: string;
    globalBrandLicense?: string[];
    inflexKitComponent?: MustShipAlone;
    isAssemblyRequired?: MustShipAlone;
    isFoldable?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isPortable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isRetractable?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumWeight?: StorageMaximumWeight;
    minimumWeight?: StorageMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    numberOfDrawers?: number;
    numberOfShelves?: number;
    pattern?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedLocations?: string[];
    recommendedRooms?: string[];
    recommendedUses?: string[];
    shape?: string;
    shelfDepth?: ShelfDepth;
    shelfStyle?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: StorageSwatchImage[];
    systemOfMeasurement?: string;
    variantAttributeNames?: StorageVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface StorageAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface StorageAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface StorageAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface StorageAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface StorageAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface StorageFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface StorageMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface StorageMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ShelfDepth {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface StorageSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: StorageVariantAttributeName;
}
export declare enum StorageVariantAttributeName {
    Capacity = "capacity",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Shape = "shape",
    Size = "size"
}
export interface TVsVideoDisplays {
    additionalProductAttributes?: TVsVideoDisplaysAdditionalProductAttribute[];
    aspectRatio?: string;
    assembledProductHeight?: TVsVideoDisplaysAssembledProductHeight;
    assembledProductLength?: TVsVideoDisplaysAssembledProductLength;
    assembledProductWeight?: TVsVideoDisplaysAssembledProductWeight;
    assembledProductWidth?: TVsVideoDisplaysAssembledProductWidth;
    audioFeatures?: string[];
    audioPowerOutput?: string;
    backlightType?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    configuration?: string;
    connections?: string[];
    count?: string;
    countPerPack?: number;
    displayTechnology?: string;
    energyGuideLabel?: string;
    features?: string[];
    hasIntegratedSpeakers?: MustShipAlone;
    hasTouchscreen?: MustShipAlone;
    inputsAndOutputs?: TVsVideoDisplaysInputsAndOutput[];
    isEnergyStarCertified?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isSmart?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumContrastRatio?: string;
    memoryCardType?: string[];
    modelNumber?: string;
    mountingPattern?: string;
    msrp?: number;
    nativeResolution?: string;
    peakAudioPowerCapacity?: TVsVideoDisplaysPeakAudioPowerCapacity;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    refreshRate?: RefreshRate;
    resolution?: string;
    responseTime?: TVsVideoDisplaysResponseTime;
    screenSize?: TVsVideoDisplaysScreenSize;
    shortDescription: string;
    size?: string;
    streamingServices?: string;
    swatchImages?: TVsVideoDisplaysSwatchImage[];
    televisionType?: string[];
    variantAttributeNames?: TVsVideoDisplaysVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface TVsVideoDisplaysAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface TVsVideoDisplaysAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface TVsVideoDisplaysAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface TVsVideoDisplaysAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface TVsVideoDisplaysAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface TVsVideoDisplaysInputsAndOutput {
    inputOutputQuantity?: number;
    inputOutputType?: string;
}
export interface TVsVideoDisplaysPeakAudioPowerCapacity {
    measure?: number;
    unit?: WattsUnit;
}
export interface RefreshRate {
    measure?: number;
    unit?: RefreshRateUnit;
}
export declare enum RefreshRateUnit {
    Hz = "Hz"
}
export interface TVsVideoDisplaysResponseTime {
    measure?: number;
    unit?: TentacledUnit;
}
export declare enum TentacledUnit {
    MS = "ms"
}
export interface TVsVideoDisplaysScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface TVsVideoDisplaysSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SwatchVariantAttribute1;
}
export declare enum SwatchVariantAttribute1 {
    Color = "color",
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    HardDriveCapacity = "hardDriveCapacity",
    MountType = "mountType",
    Platform = "platform",
    RAMMemory = "ramMemory",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export declare enum TVsVideoDisplaysVariantAttributeName {
    Color = "color",
    Configuration = "configuration",
    Count = "count",
    CountPerPack = "countPerPack",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export interface Tools {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: ToolsAdditionalProductAttribute[];
    airInlet?: AirInlet;
    amps?: ToolsAmps;
    arborDiameter?: ArborDiameter;
    assembledProductHeight?: ToolsAssembledProductHeight;
    assembledProductLength?: ToolsAssembledProductLength;
    assembledProductWeight?: ToolsAssembledProductWeight;
    assembledProductWidth?: ToolsAssembledProductWidth;
    averageAirConsumptionAt90PSI?: AverageAirConsumptionAt90PSI;
    batteryCapacity?: BatteryCapacity;
    bladeDiameter?: BladeDiameter;
    bladeLength?: BladeLength;
    bladeShank?: string;
    bladeWidth?: ToolsBladeWidth;
    blowsPerMinute?: string;
    cfmAt40Psi?: CfmAt40Psi;
    cfmAt90Psi?: CfmAt90Psi;
    chuckSize?: ChuckSize;
    chuckType?: string;
    cleaningCareAndMaintenance?: string;
    colletSize?: ColletSize;
    color?: string[];
    colorCategory?: ColorCategory[];
    cordLength?: ToolsCordLength;
    count?: string;
    countPerPack?: number;
    decibelRating?: ToolsDecibelRating;
    discSize?: DiscSize;
    engineDisplacement?: ToolsEngineDisplacement;
    features?: string[];
    finish?: string;
    fuelType?: string;
    globalBrandLicense?: string[];
    gritSize?: string;
    handing?: string;
    horsepower?: ToolsHorsepower;
    impactEnergy?: ImpactEnergy;
    inflexKitComponent?: MustShipAlone;
    isFireResistant?: MustShipAlone;
    isIndustrial?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    lightBulbType?: string;
    loadCapacity?: ToolsLoadCapacity;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumAirPressure?: MaximumAirPressure;
    maximumJawOpening?: MaximumJawOpening;
    maximumWattsOut?: MaximumWattsOut;
    modelNumber?: string;
    msrp?: number;
    noLoadSpeed?: NoLoadSpeed;
    numberOfBlades?: number;
    numberOfPoints?: number;
    numberOfSteps?: number;
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    sandingBeltSize?: string;
    sandingSpeed?: SandingSpeed;
    shankSize?: ShankSize;
    shape?: string;
    shortDescription: string;
    size?: string;
    socketDepth?: string;
    spindleThread?: string;
    squareDriveSize?: string;
    strokeLength?: StrokeLength;
    strokesPerMinute?: string;
    swatchImages?: ToolsSwatchImage[];
    tankConfiguration?: string;
    teethPerInch?: number;
    torque?: string;
    variantAttributeNames?: ToolsVariantAttributeName[];
    variantGroupId?: string;
    volts?: ToolsVolt[];
    volumeCapacity?: ToolsVolumeCapacity;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface ToolsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface AirInlet {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ToolsAmps {
    measure?: number;
    unit?: AmpsUnit;
}
export interface ArborDiameter {
    measure?: string;
    unit?: HeelHeightUnit;
}
export interface ToolsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToolsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToolsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ToolsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface AverageAirConsumptionAt90PSI {
    measure?: number;
    unit?: AverageAirConsumptionAt90PSIUnit;
}
export declare enum AverageAirConsumptionAt90PSIUnit {
    Cfm = "CFM"
}
export interface BatteryCapacity {
    measure?: number;
    unit?: BatteryCapacityUnit;
}
export declare enum BatteryCapacityUnit {
    Ah = "Ah",
    MAh = "mAh"
}
export interface BladeDiameter {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface BladeLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ToolsBladeWidth {
    measure?: number;
    unit?: CarSeatBaseDepthUnit;
}
export interface CfmAt40Psi {
    measure?: number;
    unit?: AverageAirConsumptionAt90PSIUnit;
}
export interface CfmAt90Psi {
    measure?: number;
    unit?: AverageAirConsumptionAt90PSIUnit;
}
export interface ChuckSize {
    measure?: string;
    unit?: ScreenSizeUnit;
}
export interface ColletSize {
    measure?: string;
    unit?: HeelHeightUnit;
}
export interface ToolsCordLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToolsDecibelRating {
    measure?: number;
    unit?: DecibelRatingUnit;
}
export interface DiscSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ToolsEngineDisplacement {
    measure?: number;
    unit?: EngineDisplacementUnit;
}
export interface ToolsHorsepower {
    measure?: number;
    unit?: HorsepowerUnit;
}
export interface ImpactEnergy {
    measure?: number;
    unit?: ImpactEnergyUnit;
}
export declare enum ImpactEnergyUnit {
    J = "J"
}
export interface ToolsLoadCapacity {
    measure?: number;
    unit?: SnowLoadRatingUnit;
}
export interface MaximumAirPressure {
    measure?: number;
    unit?: WorkingPressureUnit;
}
export interface MaximumJawOpening {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface MaximumWattsOut {
    measure?: number;
    unit?: MaximumWattsOutUnit;
}
export declare enum MaximumWattsOutUnit {
    Mwo = "MWO"
}
export interface NoLoadSpeed {
    measure?: number;
    unit?: NoLoadSpeedUnit;
}
export declare enum NoLoadSpeedUnit {
    RPM = "rpm"
}
export interface SandingSpeed {
    measure?: number;
    unit?: SandingSpeedUnit;
}
export declare enum SandingSpeedUnit {
    Opm = "OPM",
    Sfpm = "SFPM"
}
export interface ShankSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface StrokeLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ToolsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ToolsVariantAttributeName;
}
export declare enum ToolsVariantAttributeName {
    Amps = "amps",
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    LightBulbType = "lightBulbType",
    Shape = "shape",
    Size = "size",
    Volts = "volts",
    Watts = "watts"
}
export interface ToolsVolt {
    measure?: number;
    unit?: VoltUnit;
}
export interface ToolsVolumeCapacity {
    measure?: number;
    unit?: VolumeCapacityUnit;
}
export interface ToolsHardwareOther {
    accessoriesIncluded?: string[];
    additionalProductAttributes?: ToolsHardwareOtherAdditionalProductAttribute[];
    assembledProductHeight?: ToolsHardwareOtherAssembledProductHeight;
    assembledProductLength?: ToolsHardwareOtherAssembledProductLength;
    assembledProductWeight?: ToolsHardwareOtherAssembledProductWeight;
    assembledProductWidth?: ToolsHardwareOtherAssembledProductWidth;
    cleaningCareAndMaintenance?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    finish?: string;
    globalBrandLicense?: string[];
    isFireResistant?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isWaterproof?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    recommendedUses?: string[];
    shape?: string;
    shortDescription: string;
    size?: string;
    swatchImages?: ToolsHardwareOtherSwatchImage[];
    variantAttributeNames?: ToolsHardwareOtherVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface ToolsHardwareOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ToolsHardwareOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToolsHardwareOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToolsHardwareOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ToolsHardwareOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToolsHardwareOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SwatchVariantAttribute2;
}
export declare enum SwatchVariantAttribute2 {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Shape = "shape",
    Size = "size"
}
export declare enum ToolsHardwareOtherVariantAttributeName {
    AssembledProductHeight = "assembledProductHeight",
    AssembledProductLength = "assembledProductLength",
    AssembledProductWidth = "assembledProductWidth",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Finish = "finish",
    Shape = "shape",
    Size = "size"
}
export interface Toys {
    activity?: string[];
    additionalProductAttributes?: ToysAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    animalType?: string;
    assembledProductHeight?: ToysAssembledProductHeight;
    assembledProductLength?: ToysAssembledProductLength;
    assembledProductWeight?: ToysAssembledProductWeight;
    assembledProductWidth?: ToysAssembledProductWidth;
    assemblyInstructions?: string;
    athlete?: string[];
    awardsWon?: string[];
    capacity?: string;
    character?: string[];
    color?: string[];
    colorCategory?: ColorCategory[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    displayTechnology?: string;
    educationalFocus?: string[];
    fabricCareInstructions?: string[];
    fabricContent?: ToysFabricContent[];
    features?: string[];
    fillMaterial?: string[];
    finish?: string;
    flavor?: string;
    gender?: ArtCraftGender;
    globalBrandLicense?: string[];
    hairColorCategory?: HairColorCategory;
    inflexKitComponent?: MustShipAlone;
    ingredients?: string;
    isAssemblyRequired?: MustShipAlone;
    isInflatable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isTravelSize?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    makesNoise?: MustShipAlone;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    maximumRecommendedAge?: ToysMaximumRecommendedAge;
    maximumSpeed?: MaximumSpeed;
    maximumWeight?: ToysMaximumWeight;
    minimumRecommendedAge?: ToysMinimumRecommendedAge;
    minimumWeight?: ToysMinimumWeight;
    modelNumber?: string;
    msrp?: number;
    numberOfPlayers?: NumberOfPlayers;
    occasion?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    screenSize?: ToysScreenSize;
    seatingCapacity?: number;
    shape?: string;
    shortDescription: string;
    size?: string;
    skillLevel?: string;
    skinTone?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sport?: string[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: ToysSwatchImage[];
    targetAudience?: string[];
    theme?: string[];
    variantAttributeNames?: ToysVariantAttributeName[];
    variantGroupId?: string;
    vehicleType?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface ToysAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface ToysAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToysAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToysAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface ToysAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface ToysFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface ToysMaximumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface MaximumSpeed {
    measure?: number;
    unit?: MaximumSpeedUnit;
}
export declare enum MaximumSpeedUnit {
    Mph = "mph"
}
export interface ToysMaximumWeight {
    measure?: number;
    unit?: PurpleUnit;
}
export interface ToysMinimumRecommendedAge {
    measure?: number;
    unit?: MaximumRecommendedAgeUnit;
}
export interface ToysMinimumWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface NumberOfPlayers {
    maximumNumberOfPlayers?: number;
    minimumNumberOfPlayers?: number;
}
export interface ToysScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ToysSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: ToysVariantAttributeName;
}
export declare enum ToysVariantAttributeName {
    Capacity = "capacity",
    Character = "character",
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Flavor = "flavor",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam"
}
export interface VehicleOther {
    aaiaBrandID?: string[];
    additionalProductAttributes?: VehicleOtherAdditionalProductAttribute[];
    assembledProductHeight?: VehicleOtherAssembledProductHeight;
    assembledProductLength?: VehicleOtherAssembledProductLength;
    assembledProductWeight?: VehicleOtherAssembledProductWeight;
    assembledProductWidth?: VehicleOtherAssembledProductWidth;
    athlete?: string[];
    autographedBy?: string;
    color?: string[];
    count?: string;
    countPerPack?: number;
    countryOfOriginTextiles: CountryOfOriginTextiles;
    fabricContent?: VehicleOtherFabricContent[];
    features?: string[];
    finish?: string;
    inflexKitComponent?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    msrp?: number;
    partTerminologyID?: string[];
    pieceCount?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shape?: string;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: VehicleOtherSwatchImage[];
    variantAttributeNames?: VehicleOtherVariantAttributeName[];
    variantGroupId?: string;
    vehicleType?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface VehicleOtherAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface VehicleOtherAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VehicleOtherAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VehicleOtherAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface VehicleOtherAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VehicleOtherFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface VehicleOtherSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SwatchVariantAttribute3;
}
export declare enum SwatchVariantAttribute3 {
    Color = "color",
    Count = "count",
    Diameter = "diameter",
    Size = "size"
}
export declare enum VehicleOtherVariantAttributeName {
    Color = "color",
    Count = "count",
    Diameter = "diameter",
    Finish = "finish",
    Shape = "shape",
    Size = "size"
}
export interface VehiclePartsAccessories {
    aaiaBrandID?: string[];
    additionalProductAttributes?: VehiclePartsAccessoriesAdditionalProductAttribute[];
    amps?: VehiclePartsAccessoriesAmps;
    assembledProductHeight?: VehiclePartsAccessoriesAssembledProductHeight;
    assembledProductLength?: VehiclePartsAccessoriesAssembledProductLength;
    assembledProductWeight?: VehiclePartsAccessoriesAssembledProductWeight;
    assembledProductWidth?: VehiclePartsAccessoriesAssembledProductWidth;
    athlete?: string[];
    audioPowerOutput?: string;
    autographedBy?: string;
    automotivePartsDivision?: AutomotivePartsDivision[];
    beamAngle?: VehiclePartsAccessoriesBeamAngle;
    beamSpread?: VehiclePartsAccessoriesBeamSpread;
    breakingStrength?: BreakingStrength;
    cableLength?: VehiclePartsAccessoriesCableLength;
    candlePower?: string;
    carSpeakerSizeClass?: string[];
    carSpeakerType?: string[];
    chainLength?: VehiclePartsAccessoriesChainLength;
    coldCrankAmp?: number;
    color?: string[];
    compatibleBrands?: string[];
    compatibleCars?: string;
    compatibleDevices?: string[];
    compositeWoodCertificationCode: CompositeWoodCertificationCode;
    connections?: string[];
    count?: string;
    countPerPack?: number;
    dinSize?: string[];
    displayResolution?: string[];
    displayTechnology?: string;
    dropDistance?: string;
    fabricCareInstructions?: string[];
    fabricContent?: VehiclePartsAccessoriesFabricContent[];
    fastenerHeadType?: string;
    features?: string[];
    fillMaterial?: string[];
    filterLife?: string;
    finish?: string;
    flashPoint?: string;
    fluidOunces?: VehiclePartsAccessoriesFluidOunces;
    form?: string;
    fuelType?: string;
    hitchClass?: string;
    horsepower?: VehiclePartsAccessoriesHorsepower;
    impedance?: VehiclePartsAccessoriesImpedance;
    inDashSystem?: MustShipAlone;
    interfaceType?: string[];
    isLockable?: MustShipAlone;
    isPowered?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    isReusable?: MustShipAlone;
    keyFeatures?: string[];
    lightBulbType?: string;
    loadCapacity?: VehiclePartsAccessoriesLoadCapacity;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumMotorSpeed?: MaximumMotorSpeed;
    maximumTemperature?: VehiclePartsAccessoriesMaximumTemperature;
    modelNumber?: string;
    motorOilViscosity?: string;
    msrp?: number;
    numberOfChannels?: string;
    numberOfOutlets?: number;
    partTerminologyID?: string[];
    pieceCount?: number;
    powerType?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    receiverCompatibility?: ReceiverCompatibility;
    reserveCapacity?: ReserveCapacity;
    saeDotCompliant?: MustShipAlone;
    shackleClearance?: ShackleClearance;
    shackleDiameter?: ShackleDiameter;
    shackleLength?: ShackleLength;
    shankLength?: ShankLength;
    shape?: string;
    shearStrength?: ShearStrength;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: VehiclePartsAccessoriesSwatchImage[];
    unitsPerConsumerUnit?: number;
    variantAttributeNames?: VehiclePartsAccessoriesVariantAttributeName[];
    variantGroupId?: string;
    vehicleMake?: string;
    vehicleModel?: string;
    vehicleType?: string;
    vehicleYear?: number;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface VehiclePartsAccessoriesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface VehiclePartsAccessoriesAmps {
    measure?: number;
    unit?: AmpsUnit;
}
export interface VehiclePartsAccessoriesAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VehiclePartsAccessoriesAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VehiclePartsAccessoriesAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface VehiclePartsAccessoriesAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export declare enum AutomotivePartsDivision {
    DirectReplacement = "direct replacement",
    Motorcycle = "motorcycle",
    OEMReplacement = "oem replacement",
    PerformancePart = "performance part"
}
export interface VehiclePartsAccessoriesBeamAngle {
    measure?: number;
    unit?: BeamAngleUnit;
}
export interface VehiclePartsAccessoriesBeamSpread {
    measure?: number;
    unit?: BeamSpreadUnit;
}
export interface BreakingStrength {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export interface VehiclePartsAccessoriesCableLength {
    measure?: number;
    unit?: CableLengthUnit;
}
export interface VehiclePartsAccessoriesChainLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VehiclePartsAccessoriesFabricContent {
    materialName?: string;
    materialPercentage?: number;
}
export interface VehiclePartsAccessoriesFluidOunces {
    measure?: number;
    unit?: FluidOuncesSupplying100CaloriesUnit;
}
export interface VehiclePartsAccessoriesHorsepower {
    measure?: number;
    unit?: HorsepowerUnit;
}
export interface VehiclePartsAccessoriesImpedance {
    measure?: string;
    unit?: ImpedanceUnit;
}
export interface VehiclePartsAccessoriesLoadCapacity {
    measure?: number;
    unit?: SnowLoadRatingUnit;
}
export interface MaximumMotorSpeed {
    measure?: number;
    unit?: NoLoadSpeedUnit;
}
export interface VehiclePartsAccessoriesMaximumTemperature {
    measure?: number;
    unit?: MaximumTemperatureUnit;
}
export interface ReceiverCompatibility {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ReserveCapacity {
    measure?: number;
    unit?: DurationUnit;
}
export interface ShackleClearance {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ShackleDiameter {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ShackleLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ShankLength {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface ShearStrength {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export interface VehiclePartsAccessoriesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: VehiclePartsAccessoriesVariantAttributeName;
}
export declare enum VehiclePartsAccessoriesVariantAttributeName {
    Color = "color",
    Count = "count",
    Diameter = "diameter",
    Finish = "finish",
    Shape = "shape",
    Size = "size",
    SportsTeam = "sportsTeam",
    VehicleMake = "vehicleMake",
    VehicleModel = "vehicleModel",
    VehicleYear = "vehicleYear"
}
export interface VideoGames {
    additionalProductAttributes?: VideoGamesAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    athlete?: string[];
    autographedBy?: string;
    count?: string;
    countPerPack?: number;
    edition?: string;
    esrbRating: ESRBRating;
    features?: string[];
    globalBrandLicense?: string[];
    isDownloadableContentAvailable?: MustShipAlone;
    isOnlineMultiplayerAvailable?: MustShipAlone;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    modelNumber?: string;
    mountType?: string[];
    msrp?: number;
    numberOfChannels?: string;
    physicalMediaFormat?: VideoGamesPhysicalMediaFormat[];
    platform?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    ratingReason?: string;
    releaseDate?: Date;
    requiredPeripherals?: string;
    shortDescription: string;
    sport?: string[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: VideoGamesSwatchImage[];
    targetAudience?: string[];
    variantAttributeNames?: VideoGamesVariantAttributeName[];
    variantGroupId?: string;
    videoGameCollection?: string;
    videoGameGenre?: VideoGameGenre[];
}
export interface VideoGamesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export declare enum ESRBRating {
    Adult = "Adult",
    EarlyChildhood = "Early Childhood",
    Everyone = "Everyone",
    Everyone10 = "Everyone 10+",
    Mature = "Mature",
    Pending = "Pending",
    Teen = "Teen",
    Unrated = "Unrated"
}
export declare enum VideoGamesPhysicalMediaFormat {
    BluRay = "Blu-Ray",
    CD = "CD",
    DVD = "DVD",
    Digital = "Digital",
    DigitalHD = "Digital HD",
    GameCard = "Game Card",
    MiniDVTape = "miniDV Tape",
    PrintedMedia = "Printed Media",
    The3DBluRay = "3D Blu-ray",
    The4KUltraHD = "4K Ultra HD",
    USBStick = "USB stick"
}
export interface VideoGamesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: VideoGamesVariantAttributeName;
}
export declare enum VideoGamesVariantAttributeName {
    Count = "count",
    CountPerPack = "countPerPack",
    Edition = "edition",
    PhysicalMediaFormat = "physicalMediaFormat",
    Platform = "platform",
    SportsTeam = "sportsTeam"
}
export declare enum VideoGameGenre {
    ActionAdventure = "Action & Adventure",
    ActionRolePlayingGame = "Action Role-playing Game",
    AdultVideoGame = "Adult Video Game",
    Advergame = "Advergame",
    ArtGame = "Art Game",
    BoardGame = "Board Game",
    CarSimulation = "Car Simulation",
    CardGame = "Card Game",
    CasualGame = "Casual Game",
    ChristianGame = "Christian Game",
    CitySimulation = "City Simulation",
    ConstructionAndManagementSimulation = "Construction and Management Simulation",
    EducationalGame = "Educational Game",
    ElectronicSports = "Electronic Sports",
    ExerciseGame = "Exercise Game",
    FlightSimulation = "Flight Simulation",
    HealthFitness = "Health & Fitness",
    Horror = "Horror",
    KidsFamily = "Kids & Family",
    LifeSimulation = "Life Simulation",
    MassivelyMultiplayerOnlineGame = "Massively Multiplayer Online Game",
    MilitaryVehicleSimulation = "Military Vehicle Simulation",
    MotionGame = "Motion Game",
    MusicGame = "Music Game",
    PartyGame = "Party Game",
    ProgrammingGame = "Programming Game",
    PuzzleGame = "Puzzle Game",
    RacingGame = "Racing Game",
    RealTimeStrategy = "Real-time Strategy",
    RealTimeTactics = "Real-time Tactics",
    RolePlaying = "Role-playing",
    SandboxGame = "Sandbox Game",
    SeriousGame = "Serious Game",
    Simulation = "Simulation",
    SportsGame = "Sports Game",
    Survival = "Survival",
    SurvivalHorror = "Survival Horror",
    TacticalRolePlayingGame = "Tactical Role-playing Game",
    TelevisionTieIn = "Television Tie-in",
    TowerDefense = "Tower Defense",
    TradingCardGame = "Trading Card Game",
    TriviaGame = "Trivia Game",
    TurnBasedStrategy = "Turn-based Strategy",
    TurnBasedTactical = "Turn-based Tactical",
    XGames = "X Games"
}
export interface VideoProjectors {
    additionalProductAttributes?: VideoProjectorsAdditionalProductAttribute[];
    aspectRatio?: string;
    assembledProductHeight?: VideoProjectorsAssembledProductHeight;
    assembledProductLength?: VideoProjectorsAssembledProductLength;
    assembledProductWeight?: VideoProjectorsAssembledProductWeight;
    assembledProductWidth?: VideoProjectorsAssembledProductWidth;
    brightness?: VideoProjectorsBrightness;
    color?: string[];
    count?: string;
    countPerPack?: number;
    displayTechnology?: string;
    features?: string[];
    has3dCapabilities?: MustShipAlone;
    hasIntegratedSpeakers?: MustShipAlone;
    inputsAndOutputs?: VideoProjectorsInputsAndOutput[];
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    lampLife?: LampLife;
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumContrastRatio?: string;
    modelNumber?: string;
    mountType?: string[];
    msrp?: number;
    nativeResolution?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    resolution?: string;
    screenSize?: VideoProjectorsScreenSize;
    shortDescription: string;
    size?: string;
    swatchImages?: VideoProjectorsSwatchImage[];
    throwRatio?: string;
    variantAttributeNames?: VideoProjectorsVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    wirelessTechnologies?: string[];
}
export interface VideoProjectorsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface VideoProjectorsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VideoProjectorsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VideoProjectorsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface VideoProjectorsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface VideoProjectorsBrightness {
    measure?: number;
    unit?: BrightnessUnit;
}
export interface VideoProjectorsInputsAndOutput {
    inputOutputQuantity?: number;
    inputOutputType?: string;
}
export interface LampLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface VideoProjectorsScreenSize {
    measure?: number;
    unit?: ScreenSizeUnit;
}
export interface VideoProjectorsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SwatchVariantAttribute4;
}
export declare enum SwatchVariantAttribute4 {
    Count = "count",
    CountPerPack = "countPerPack",
    MountType = "mountType",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export declare enum VideoProjectorsVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    MountType = "mountType",
    Resolution = "resolution",
    ScreenSize = "screenSize",
    Size = "size"
}
export interface Watches {
    accentStone?: AryStoneType[];
    activity?: string[];
    additionalProductAttributes?: WatchesAdditionalProductAttribute[];
    ageGroup?: ArtCraftAgeGroup[];
    bandWidth?: BandWidth;
    batteryLife?: WatchesBatteryLife;
    carats?: WatchesCarats;
    character?: string[];
    claspType?: ClaspType[];
    clockNumberType?: string;
    clockWatchFaceColor?: string;
    color?: string[];
    colorCategory?: ColorCategory[];
    count?: string;
    countPerPack?: number;
    features?: string[];
    gemstone?: AryStoneType;
    gemstoneShape?: PrimaryStoneShape;
    gender?: BabyClothingGender;
    isPrimaryVariant?: MustShipAlone;
    isWaterResistant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    metal?: MetalType;
    metalPurity?: string;
    modelNumber?: string;
    msrp?: number;
    occasion?: string[];
    plating?: string;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    seasonCode?: SeasonCode;
    seasonYear?: number;
    shortDescription: string;
    size?: string;
    smallPartsWarnings: SmallPartsWarningCode[];
    sportsLeague?: string[];
    sportsTeam?: string[];
    swatchImages?: WatchesSwatchImage[];
    theme?: string[];
    totalDiamondWeight?: WatchesTotalDiamondWeight;
    variantAttributeNames?: WatchesVariantAttributeName[];
    variantGroupId?: string;
    warrantyText?: string;
    warrantyURL?: string;
    watchBandColor?: string;
    watchBandLength?: WatchBandLength;
    watchBandMaterial?: WatchBandMaterial[];
    watchBezelMaterial?: string[];
    watchCaseMaterial?: WatchCaseMaterial;
    watchCaseShape?: WatchFaceShape;
    watchCaseSize?: WatchCaseSize;
    watchCaseThickness?: WatchCaseThickness;
    watchComplication?: string;
    watchCrystalMaterial?: WatchCrystalMaterial[];
    watchMovement?: WatchMovement;
    watchMovementType?: WatchMovementType[];
    watchStyle?: string[];
}
export interface WatchesAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface BandWidth {
    measure?: number;
    unit?: BootShaftCircumferenceUnit;
}
export interface WatchesBatteryLife {
    measure?: number;
    unit?: StandbyTimeUnit;
}
export interface WatchesCarats {
    measure?: number;
    unit?: CaratsUnit;
}
export interface WatchesSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: string;
}
export interface WatchesTotalDiamondWeight {
    measure?: number;
    unit?: CaratsUnit;
}
export declare enum WatchesVariantAttributeName {
    Color = "color",
    Count = "count",
    CountPerPack = "countPerPack",
    Material = "material",
    Plating = "plating",
    SportsTeam = "sportsTeam",
    WatchBandMaterial = "watchBandMaterial",
    WatchStyle = "watchStyle"
}
export interface WatchBandLength {
    measure?: number;
    unit?: BootShaftCircumferenceUnit;
}
export declare enum WatchBandMaterial {
    CarbonFiber = "Carbon Fiber",
    Copper = "Copper",
    Gold = "Gold",
    GoldPlated = "Gold-plated",
    Leather = "Leather",
    Nylon = "Nylon",
    Other = "Other",
    Platinum = "Platinum",
    Silicone = "Silicone",
    SilverPlated = "Silver-plated",
    StainlessSteel = "Stainless Steel",
    SterlingSilver = "Sterling Silver",
    Titanium = "Titanium",
    Tungsten = "Tungsten"
}
export declare enum WatchCaseMaterial {
    Aluminum = "Aluminum",
    CarbonFiber = "Carbon Fiber",
    Ceramic = "Ceramic",
    GoldPlated = "Gold-plated",
    Other = "Other",
    Plastic = "Plastic",
    Platinum = "Platinum",
    Pvd = "PVD",
    Rubber = "Rubber",
    Silicone = "Silicone",
    StainlessSteel = "Stainless Steel",
    The14KGold = "14K Gold",
    The18KGold = "18K Gold",
    Titanium = "Titanium"
}
export declare enum WatchFaceShape {
    Oval = "Oval",
    Rectangle = "Rectangle",
    Round = "Round",
    Square = "Square",
    Tonneau = "Tonneau"
}
export interface WatchCaseSize {
    measure?: number;
    unit?: HeelHeightUnit;
}
export interface WatchCaseThickness {
    measure?: string;
    unit?: BootShaftCircumferenceUnit;
}
export declare enum WatchCrystalMaterial {
    Acrylic = "Acrylic",
    Mineral = "Mineral",
    Other = "Other",
    Plastic = "Plastic",
    Sapphire = "Sapphire",
    SyntheticSapphire = "Synthetic Sapphire"
}
export declare enum WatchMovement {
    Automatic = "Automatic",
    Manual = "Manual",
    Other = "Other",
    Quartz = "Quartz"
}
export declare enum WatchMovementType {
    AnalogQuartz = "Analog Quartz",
    Automatic = "Automatic",
    JapaneseQuartz = "Japanese Quartz",
    Manual = "Manual",
    Mechanical = "Mechanical",
    SmartWatch = "Smart Watch",
    SwissQuartz = "Swiss Quartz"
}
export interface Watercraft {
    additionalProductAttributes?: WatercraftAdditionalProductAttribute[];
    airDraft?: AirDraft;
    assembledProductHeight?: WatercraftAssembledProductHeight;
    assembledProductLength?: WatercraftAssembledProductLength;
    assembledProductWeight?: WatercraftAssembledProductWeight;
    assembledProductWidth?: WatercraftAssembledProductWidth;
    athlete?: string[];
    averageFuelConsumption?: WatercraftAverageFuelConsumption;
    beam?: Beam;
    boreStroke?: string;
    color?: string[];
    compressionRatio?: string;
    coolingSystem?: string;
    draft?: Draft;
    dryWeight?: DryWeight;
    engineDisplacement?: WatercraftEngineDisplacement;
    engineLocation?: string;
    engineModel?: string;
    features?: string[];
    fuelCapacity?: WatercraftFuelCapacity;
    fuelRequirement?: string;
    fuelSystem?: string;
    hullLength?: HullLength;
    impellerPropeller?: string;
    inductionSystem?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    maximumEnginePower?: WatercraftMaximumEnginePower;
    modelNumber?: string;
    msrp?: number;
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    propulsionSystem?: string;
    seatingCapacity?: number;
    shortDescription: string;
    size?: string;
    sportsLeague?: string[];
    submodel?: string;
    swatchImages?: WatercraftSwatchImage[];
    thrust?: Thrust;
    topSpeed?: WatercraftTopSpeed;
    variantAttributeNames?: WatercraftVariantAttributeName[];
    variantGroupId?: string;
    vehicleMake?: string;
    vehicleModel?: string;
    vehicleType?: string;
    vehicleYear?: number;
    warrantyText?: string;
    warrantyURL?: string;
    waterCapacity?: WaterCapacity;
}
export interface WatercraftAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface AirDraft {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WatercraftAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WatercraftAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WatercraftAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface WatercraftAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WatercraftAverageFuelConsumption {
    measure?: number;
    unit?: AverageFuelConsumptionUnit;
}
export interface Beam {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface Draft {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface DryWeight {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export interface WatercraftEngineDisplacement {
    measure?: number;
    unit?: EngineDisplacementUnit;
}
export interface WatercraftFuelCapacity {
    measure?: number;
    unit?: FuelCapacityUnit;
}
export interface HullLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WatercraftMaximumEnginePower {
    measure?: number;
    unit?: MaximumEnginePowerUnit;
}
export interface WatercraftSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: SwatchVariantAttribute5;
}
export declare enum SwatchVariantAttribute5 {
    Color = "color",
    EngineModel = "engineModel",
    VehicleMake = "vehicleMake",
    VehicleModel = "vehicleModel",
    VehicleYear = "vehicleYear"
}
export interface Thrust {
    measure?: number;
    unit?: MaximumLoadWeightUnit;
}
export interface WatercraftTopSpeed {
    measure?: number;
    unit?: TopSpeedUnit;
}
export declare enum WatercraftVariantAttributeName {
    Color = "color",
    EngineModel = "engineModel",
    Size = "size",
    VehicleMake = "vehicleMake",
    VehicleModel = "vehicleModel",
    VehicleYear = "vehicleYear"
}
export interface WaterCapacity {
    measure?: number;
    unit?: FuelCapacityUnit;
}
export interface WheelsWheelComponents {
    aaiaBrandID?: string[];
    additionalProductAttributes?: WheelsWheelComponentsAdditionalProductAttribute[];
    assembledProductHeight?: WheelsWheelComponentsAssembledProductHeight;
    assembledProductLength?: WheelsWheelComponentsAssembledProductLength;
    assembledProductWeight?: WheelsWheelComponentsAssembledProductWeight;
    assembledProductWidth?: WheelsWheelComponentsAssembledProductWidth;
    color?: string[];
    compatibleTireSize?: string;
    count?: string;
    countPerPack?: number;
    diameter?: WheelsWheelComponentsDiameter;
    features?: string[];
    finish?: string;
    isPrimaryVariant?: MustShipAlone;
    keyFeatures?: string[];
    mainImageUrl: string;
    manufacturer: string;
    manufacturerPartNumber?: string;
    material?: string[];
    modelNumber?: string;
    msrp?: number;
    numberOfSpokes?: number;
    partTerminologyID?: string[];
    productSecondaryImageURL?: string[];
    prop65WarningText: string;
    shortDescription: string;
    swatchImages?: WheelsWheelComponentsSwatchImage[];
    variantAttributeNames?: WheelsWheelComponentsVariantAttributeName[];
    variantGroupId?: string;
    vehicleRimSize?: string;
    warrantyText?: string;
    warrantyURL?: string;
}
export interface WheelsWheelComponentsAdditionalProductAttribute {
    productAttributeName: string;
    productAttributeValue: string;
}
export interface WheelsWheelComponentsAssembledProductHeight {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WheelsWheelComponentsAssembledProductLength {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WheelsWheelComponentsAssembledProductWeight {
    measure?: number;
    unit?: AssembledProductWeightUnit;
}
export interface WheelsWheelComponentsAssembledProductWidth {
    measure?: number;
    unit?: AssembledProductHeightUnit;
}
export interface WheelsWheelComponentsDiameter {
    measure?: number;
    unit?: RoughInDistanceUnit;
}
export interface WheelsWheelComponentsSwatchImage {
    swatchImageUrl?: string;
    swatchVariantAttribute?: WheelsWheelComponentsVariantAttributeName;
}
export declare enum WheelsWheelComponentsVariantAttributeName {
    Color = "color",
    Count = "count",
    Diameter = "diameter",
    Finish = "finish",
    Size = "size"
}
export interface MPItemFeedHeader {
    feedDate?: Date;
    locale: Locale;
    mart?: Mart;
    processMode: ProcessMode;
    requestBatchId?: string;
    requestId?: string;
    sellingChannel: SellingChannel;
    subCategory: SubCategory;
    subset: Subset;
    version: SpecVersion;
}
export declare enum Locale {
    En = "en"
}
export declare enum Mart {
    AsdaGm = "ASDA_GM",
    WalmartCA = "WALMART_CA",
    WalmartUs = "WALMART_US"
}
export declare enum ProcessMode {
    Merge = "MERGE",
    Replace = "REPLACE"
}
export declare enum SellingChannel {
    Marketplacewfs = "marketplacewfs"
}
export declare enum SubCategory {
    AnimalAccessories = "animal_accessories",
    AnimalFood = "animal_food",
    AnimalHealthAndGrooming = "animal_health_and_grooming",
    AnimalOther = "animal_other",
    ArtAndCraftOther = "art_and_craft_other",
    BabyClothing = "baby_clothing",
    BabyFood = "baby_food",
    BabyFurniture = "baby_furniture",
    BabyOther = "baby_other",
    BabyToys = "baby_toys",
    Bedding = "bedding",
    BuildingSupply = "building_supply",
    CamerasAndLenses = "cameras_and_lenses",
    CarriersAndAccessoriesOther = "carriers_and_accessories_other",
    CasesAndBags = "cases_and_bags",
    CellPhones = "cell_phones",
    CeremonialClothingAndAccessories = "ceremonial_clothing_and_accessories",
    ChildCarSeats = "child_car_seats",
    CleaningAndChemical = "cleaning_and_chemical",
    ClothingOther = "clothing_other",
    ComputerComponents = "computer_components",
    Computers = "computers",
    Costumes = "costumes",
    Cycling = "cycling",
    DecorationsAndFavors = "decorations_and_favors",
    Electrical = "electrical",
    ElectronicsAccessories = "electronics_accessories",
    ElectronicsCables = "electronics_cables",
    ElectronicsOther = "electronics_other",
    FoodAndBeverageOther = "food_and_beverage_other",
    FootwearOther = "footwear_other",
    FuelsAndLubricants = "fuels_and_lubricants",
    Funeral = "funeral",
    FurnitureOther = "furniture_other",
    GardenAndPatioOther = "garden_and_patio_other",
    GiftSupplyAndAwards = "gift_supply_and_awards",
    GrillsAndOutdoorCooking = "grills_and_outdoor_cooking",
    Hardware = "hardware",
    HealthAndBeautyElectronics = "health_and_beauty_electronics",
    HomeOther = "home_other",
    InstrumentAccessories = "instrument_accessories",
    JewelryOther = "jewelry_other",
    LandVehicles = "land_vehicles",
    LargeAppliances = "large_appliances",
    MedicalAids = "medical_aids",
    MedicineAndSupplements = "medicine_and_supplements",
    Movies = "movies",
    Music = "music",
    MusicCasesAndBags = "music_cases_and_bags",
    MusicalInstruments = "musical_instruments",
    OfficeOther = "office_other",
    Optical = "optical",
    Optics = "optics",
    OtherOther = "other_other",
    PersonalCare = "personal_care",
    PhotoAccessories = "photo_accessories",
    PlumbingAndHvac = "plumbing_and_hvac",
    PrintersScannersAndImaging = "printers_scanners_and_imaging",
    SafetyAndEmergency = "safety_and_emergency",
    Software = "software",
    SoundAndRecording = "sound_and_recording",
    SportAndRecreationOther = "sport_and_recreation_other",
    Storage = "storage",
    Tools = "tools",
    ToolsAndHardwareOther = "tools_and_hardware_other",
    ToysOther = "toys_other",
    TvsAndVideoDisplays = "tvs_and_video_displays",
    VehicleOther = "vehicle_other",
    VehiclePartsAndAccessories = "vehicle_parts_and_accessories",
    VideoGames = "video_games",
    VideoProjectors = "video_projectors",
    WatchesOther = "watches_other",
    Watercraft = "watercraft",
    WheelsAndWheelComponents = "wheels_and_wheel_components"
}
export declare enum Subset {
    External = "EXTERNAL",
    Internal = "INTERNAL"
}
export declare enum SpecVersion {
    The12 = "1.2"
}
export declare class Convert {
    static toMpWfsItem42(json: string): MpWfsItem42;
    static mpWfsItem42ToJson(value: MpWfsItem42): string;
}