Ballast.Types

Synopsis

• newtype Username = Username {
  • unUsername :: ByteString
  }
• newtype Password = Password {
  • unPassword :: ByteString
  }
• newtype SKU = SKU {
  • unSku :: Text
  }
• mkSku :: Text -> Maybe SKU
• data GetRate = GetRate {
  • rateOptions :: RateOptions
  • rateOrder :: RateOrder
  }
• data RateOptions = RateOptions {
  • rateOptionCurrency :: Currency
  • rateOptionGroupBy :: GroupBy
  • rateOptionWarehouseId :: Maybe WarehouseId
  • rateOptionWarehouseExternalId :: Maybe WarehouseExternalId
  • rateOptionWarehouseRegion :: Maybe WarehouseRegion
  • rateOptionIgnoreUnknownSkus :: Maybe IgnoreUnknownSkus
  • rateOptionCanSplit :: CanSplit
  • rateOptionWarehouseArea :: WarehouseArea
  • rateOptionChannelName :: Maybe ChannelName
  • rateOptionExpectedShipDate :: Maybe ExpectedShipDate
  • rateOptionHighAccuracyEstimates :: Maybe HighAccuracyEstimates
  }
• data CanSplit
  • = CanSplit
  • | CanNotSplit
• data RateOrder = RateOrder {
  • rateOrderShipTo :: ShipTo
  • rateOrderItems :: Items
  }
• data ShipTo = ShipTo {
  • shipToAddress1 :: AddressLine
  • shipToAddress2 :: AddressLine
  • shipToAddress3 :: AddressLine
  • shipToCity :: City
  • shipToPostalCode :: PostalCode
  • shipToRegion :: Region
  • shipToCountry :: Country
  • shipToIsCommercial :: IsCommercial
  • shipToIsPoBox :: IsPoBox
  }
• data IsCommercial
  • = Commercial
  • | NotCommercial
• data IsPoBox
  • = PoBox
  • | NotPoBox
• type Items = [ItemInfo]
• data ItemInfo = ItemInfo (SKU, Quantity)
• newtype Quantity = Quantity {
  • unQuantity :: Integer
  }
• newtype AddressLine = AddressLine {
  • unAddressLine :: Text
  }
• newtype City = City {
  • unCity :: Text
  }
• newtype PostalCode = PostalCode {
  • unPostalCode :: Text
  }
• newtype Region = Region {
  • unRegion :: Text
  }
• data IgnoreUnknownSkus
  • = IgnoreUnknownSkus
  • | DontIgnoreUnknownSkus
• newtype Country = Country {
  • unCountry :: Text
  }
• data Currency = USD
• data GroupBy
  • = GroupByAll
  • | GroupByWarehouse
• newtype WarehouseArea = WarehouseArea {
  • unWarehouseArea :: Text
  }
• data RateResponse = RateResponse {
  • rateResponseStatus :: ResponseStatus
  • rateResponseMessage :: ResponseMessage
  • rateResponseWarnings :: Maybe ResponseWarnings
  • rateResponseErrors :: Maybe ResponseErrors
  • rateResponseResourceLocation :: Maybe ResponseResourceLocation
  • rateResponseResource :: Maybe RateResource
  }
• newtype ResponseStatus = ResponseStatus {
  • unResponseStatus :: Integer
  }
• newtype ResponseMessage = ResponseMessage {
  • unResponseMessage :: Text
  }
• newtype ResponseWarnings = ResponseWarnings {
  • unResponseWarnings :: [Warning]
  }
• newtype ResponseErrors = ResponseErrors {
  • unResponseErrors :: [Error]
  }
• newtype ResponseResourceLocation = ResponseResourceLocation {
  • unResponseResourceLocation :: Text
  }
• data Warning = Warning {
  • warningCode :: WarningCode
  • warningMessage :: WarningMessage
  • warningType :: WarningType
  }
• newtype WarningCode = WarningCode {
  • unWarningCode :: Text
  }
• newtype WarningMessage = WarningMessage {
  • unWarningMessage :: Text
  }
• data WarningType
  • = WarningWarning
  • | WarningError
• data Error = Error {
  • errorCode :: ErrorCode
  • errorMessage :: ErrorMessage
  • errorType :: ErrorType
  }
• data ErrorCode
  • = ErrorCodeText Text
  • | ErrorCodeInteger Integer
• newtype ErrorMessage = ErrorMessage {
  • unErrorMessage :: Text
  }
• data ErrorType
  • = ErrorWarning
  • | ErrorError
• data RateResource = RateResource {
  • resourceGroupBy :: GroupBy
  • resourceRates :: Rates
  }
• newtype Rates = Rates {
  • rateServiceOptions :: [ServiceOptions]
  }
• data ServiceOptions = ServiceOptions {
  • sOptsServiceOptions :: [ServiceOption]
  • sOptsGroupId :: Maybe GroupId
  • sOptsGroupExternalId :: Maybe GroupExternalId
  }
• type GroupId = Id
• type GroupExternalId = ExternalId
• newtype Id = Id {
  • unId :: Integer
  }
• newtype ExternalId = ExternalId {
  • unExternalId :: Text
  }
• data ServiceOption = ServiceOption {
  • sOptServiceLevelCode :: ServiceLevelCode
  • sOptServiceLevelName :: ServiceOptionServiceLevelName
  • sOptShipments :: [Shipment]
  }
• newtype ServiceOptionServiceLevelName = ServiceOptionServiceLevelName {
  • unServiceOptionServiceLevelName :: Text
  }
• data ServiceLevelCode
  • = DomesticGround
  • | DomesticTwoDay
  • | DomesticOneDay
  • | InternationalEconomy
  • | InternationalStandard
  • | InternationalPlus
  • | InternationalPremium
• data Shipment = Shipment {
  • shipmentWarehouseName :: WarehouseName
  • shipmentCarrier :: Carrier
  • shipmentCost :: Cost
  • shipmentSubtotals :: [Subtotal]
  • shipmentPieces :: [Piece]
  • shipmentExpectedShipDate :: Maybe ExpectedShipDate
  • shipmentExpectedDeliveryDateMin :: Maybe ExpectedDeliveryDateMin
  • shipmentExpectedDeliveryDateMax :: Maybe ExpectedDeliveryDateMax
  }
• newtype WarehouseName = WarehouseName {
  • unWarehouseName :: Text
  }
• newtype ExpectedShipDate = ExpectedShipDate {
  • unExpectedShipDate :: UTCTime
  }
• type ExpectedDeliveryDateMin = ExpectedShipDate
• type ExpectedDeliveryDateMax = ExpectedShipDate
• data Carrier = Carrier {
  • carrierCode :: CarrierCode
  • carrierName :: CarrierName
  • carrierProperties :: CarrierProperties
  }
• newtype CarrierCode = CarrierCode {
  • unCarrierCode :: Text
  }
• newtype CarrierName = CarrierName {
  • unCarrierName :: Text
  }
• newtype CarrierProperties = CarrierProperties {
  • unCarrierProperties :: [Text]
  }
• data Cost = Cost {
  • costCurrency :: CostCurrency
  • costType :: CostType
  • costName :: CostName
  • costAmount :: CostAmount
  • costConverted :: CostConverted
  • costOriginalCost :: CostOriginalCost
  • costOriginalCurrency :: CostOriginalCurrency
  }
• newtype CostCurrency = CostCurrency {
  • unCostCurrency :: Text
  }
• newtype CostType = CostType {
  • unCostType :: Text
  }
• newtype CostName = CostName {
  • unCostName :: Text
  }
• newtype CostAmount = CostAmount {
  • unCostAmount :: Centi
  }
• newtype CostConverted = CostConverted {
  • unCostConverted :: Bool
  }
• newtype CostOriginalCost = CostOriginalCost {
  • unCostOriginalCost :: Centi
  }
• newtype CostOriginalCurrency = CostOriginalCurrency {
  • unCostOriginalCurrency :: Text
  }
• data Subtotal = Subtotal {
  • subtotalCurrency :: SubtotalCurrency
  • sbutotalType :: SubtotalType
  • subtotalName :: SubtotalName
  • subtotalAmount :: SubtotalAmount
  • subtotalConverted :: SubtotalConverted
  • subtotalOriginalCost :: SubtotalOriginalCost
  • subtotalOriginalCurrency :: SubtotalOriginalCurrency
  }
• newtype SubtotalCurrency = SubtotalCurrency {
  • unSubtotalCurrency :: Text
  }
• newtype SubtotalType = SubtotalType {
  • unSubtotalType :: Text
  }
• newtype SubtotalName = SubtotalName {
  • unSubtotalName :: Text
  }
• newtype SubtotalAmount = SubtotalAmount {
  • unSubtotalAmount :: Centi
  }
• newtype SubtotalConverted = SubtotalConverted {
  • unSubtotalConverted :: Bool
  }
• newtype SubtotalOriginalCost = SubtotalOriginalCost {
  • unSubtotalOriginalCost :: Centi
  }
• newtype SubtotalOriginalCurrency = SubtotalOriginalCurrency {
  • unSubtotalOriginalCurrency :: Text
  }
• data Piece = Piece {
  • pieceLength :: PieceLength
  • pieceWidth :: PieceWidth
  • pieceHeight :: PieceHeight
  • pieceWeight :: PieceWeight
  • pieceSubweights :: [PieceSubWeight]
  • pieceContents :: [PieceContent]
  }
• data PieceLength = PieceLength {
  • pieceLengthAmount :: Length
  • pieceLengthUnits :: PieceLengthUnits
  }
• newtype Length = Length {
  • unLength :: Double
  }
• newtype PieceLengthUnits = PieceLengthUnits {
  • unPieceLengthUnits :: Text
  }
• data PieceWidth = PieceWidth {
  • pieceWidthAmount :: Width
  • pieceWidthUnits :: PieceWidthUnits
  }
• newtype Width = Width {
  • unWidth :: Double
  }
• newtype PieceWidthUnits = PieceWidthUnits {
  • unPieceWidthUnits :: Text
  }
• data PieceHeight = PieceHeight {
  • pieceHeightAmount :: Height
  • pieceHeightUnits :: PieceHeightUnits
  }
• newtype Height = Height {
  • unHeight :: Double
  }
• newtype PieceHeightUnits = PieceHeightUnits {
  • unPieceHeightUnits :: Text
  }
• data PieceWeight = PieceWeight {
  • pieceWeightAmount :: Weight
  • pieceWeightUnits :: PieceWeightUnits
  • pieceWeightType :: PieceWeightType
  }
• newtype Weight = Weight {
  • unWeight :: Double
  }
• newtype PieceWeightUnits = PieceWeightUnits {
  • unPieceWeightUnits :: Text
  }
• newtype PieceWeightType = PieceWeightType {
  • unPieceWeightType :: Text
  }
• data PieceSubWeight = PieceSubWeight {
  • pieceSubWeightAmount :: Weight
  • pieceSubWeightUnits :: PieceSubWeightUnits
  • pieceSubWeightType :: PieceSubWeightType
  }
• newtype PieceSubWeightUnits = PieceSubWeightUnits {
  • unPieceSubWeightUnits :: Text
  }
• newtype PieceSubWeightType = PieceSubWeightType {
  • unPieceSubWeightType :: Text
  }
• data PieceContent = PieceContent {
  • pieceContentSku :: SKU
  • pieceContentQuantity :: Quantity
  }
• type Reply = Response ByteString
• type Method = Method
• data ShipwireRequest a b c = ShipwireRequest {
  • rMethod :: Method
  • endpoint :: Text
  • params :: [Params TupleBS8 ByteString]
  }
• mkShipwireRequest :: Method -> Text -> [Params TupleBS8 ByteString] -> ShipwireRequest a b c
• type family ShipwireReturn a :: *
• data RateRequest
• data StockRequest
• data StockResponse = StockResponse {
  • stockResponseStatus :: ResponseStatus
  • stockResponseMessage :: ResponseMessage
  • stockResponseWarnings :: Maybe ResponseWarnings
  • stockResponseErrors :: Maybe ResponseErrors
  • stockResponseResourceLocation :: Maybe ResponseResourceLocation
  • stockResponseResource :: StockResource
  }
• newtype ParentId = ParentId {
  • parentId :: Text
  }
• newtype ProductIdParam = ProductIdParam {
  • productIdParam :: [Text]
  }
• newtype ProductExternalIdParam = ProductExternalIdParam {
  • productExternalIdParam :: [Text]
  }
• newtype WarehouseIdParam = WarehouseIdParam {
  • warehouseIdParam :: [Text]
  }
• newtype WarehouseExternalIdParam = WarehouseExternalIdParam {
  • warehouseExternalIdParam :: [Text]
  }
• newtype WarehouseRegionParam = WarehouseRegionParam {
  • warehouseRegionParam :: [Text]
  }
• newtype WarehouseAreaParam = WarehouseAreaParam {
  • warehouseAreaParam :: [Text]
  }
• newtype ChannelName = ChannelName {
  • channelName :: Text
  }
• newtype IncludeEmpty = IncludeEmpty {
  • includeEmpty :: Integer
  }
• newtype VendorIdParam = VendorIdParam {
  • vendorIdParam :: [Integer]
  }
• newtype VendorExternalIdParam = VendorExternalIdParam {
  • vendorExternalIdParam :: [Integer]
  }
• newtype DisableAutoBreakLots = DisableAutoBreakLots {
  • disableAutoBreakLots :: Text
  }
• data Mode
  • = IncludingHigherLevelQuantitiesWithLots
  • | IncludingHigherLevelQuantitiesWithoutLots
  • | NotIncludingHigherLevelQuantitiesWithLots
  • | NotIncludingHigherLevelQuantitiesWithoutLots
• modeToBS8 :: Mode -> ByteString
• newtype IncludeEmptyShipwireAnywhere = IncludeEmptyShipwireAnywhere {
  • inclEmptyShipwireAnywhere :: Text
  }
• newtype Offset = Offset {
  • unOffset :: Integer
  }
• newtype Total = Total {
  • unTotal :: Integer
  }
• newtype Previous = Previous {
  • unPrevious :: Text
  }
• newtype Next = Next {
  • unNext :: Text
  }
• newtype Limit = Limit {
  • unLimit :: Integer
  }
• data StockResource = StockResource {
  • stockResponseOffset :: ResponseOffset
  • stockResponseTotal :: ResponseTotal
  • stockResponsePrevious :: Maybe ResponsePrevious
  • stockResponseNext :: Maybe ResponseNext
  • stockResponseItems :: [StockItem]
  }
• newtype ResponseOffset = ResponseOffset {
  • unResponseOffset :: Integer
  }
• newtype ResponseTotal = ResponseTotal {
  • unResponseTotal :: Integer
  }
• newtype ResponsePrevious = ResponsePrevious {
  • unResponsePrevious :: Text
  }
• newtype ResponseNext = ResponseNext {
  • unResponseNext :: Text
  }
• data StockItem = StockItem {
  • stockItemResourceLocation :: Maybe ResponseResourceLocation
  • stockItemResource :: StockItemResource
  }
• data StockItemResource = StockItemResource {
  • sirProductId :: Maybe ProductId
  • sirProductExternalId :: Maybe ProductExternalId
  • sirSku :: SKU
  • sirIsBundle :: IsBundle
  • sirIsAlias :: IsAlias
  • sirWarehouseRegion :: WarehouseRegion
  • sirWarehouseId :: WarehouseId
  • sirWarehouseExternalId :: Maybe WarehouseExternalId
  • sirPending :: StockItemResourcePending
  • sirGood :: StockItemResourceGood
  • sirReserved :: StockItemResourceReserved
  • sirBackordered :: StockItemResourceBackordered
  • sirShipping :: StockItemResourceShipping
  • sirShipped :: StockItemResourceShipped
  • sirCreating :: StockItemResourceCreating
  • sirConsuming :: StockItemResourceConsuming
  • sirConsumed :: StockItemResourceConsumed
  • sirCreated :: StockItemResourceCreated
  • sirDamaged :: StockItemResourceDamaged
  • sirReturned :: StockItemResourceReturned
  • sirInreview :: StockItemResourceInReview
  • sirAvailableDate :: Maybe StockItemResourceAvailableDate
  • sirShippedLastDay :: StockItemResourceShippedLastDay
  • sirShippedLastWeek :: StockItemResourceShippedLastWeek
  • sirShippedLast4Weeks :: StockItemResourceShippedLast4Weeks
  • sirOrderedLastDay :: StockItemResourceOrderedLastDay
  • sirOrderedLastWeek :: StockItemResourceOrderedLastWeek
  • sirOrderedLast4Weeks :: StockItemResourceOrderedLast4Weeks
  }
• newtype ProductId = ProductId {
  • unProductId :: Integer
  }
• type ProductExternalId = ExternalId
• newtype WarehouseRegion = WarehouseRegion {
  • unWarehouseRegion :: Text
  }
• newtype StockItemResourcePending = StockItemResourcePending {
  • unStockItemResourcePending :: Integer
  }
• newtype StockItemResourceGood = StockItemResourceGood {
  • unStockItemResourceGood :: Integer
  }
• newtype StockItemResourceReserved = StockItemResourceReserved {
  • unStockItemResourceReserved :: Integer
  }
• newtype StockItemResourceBackordered = StockItemResourceBackordered {
  • unStockItemResourceBackorderd :: Integer
  }
• newtype StockItemResourceShipping = StockItemResourceShipping {
  • unStockItemResourceShipping :: Integer
  }
• newtype StockItemResourceShipped = StockItemResourceShipped {
  • unStockItemResourceShipped :: Integer
  }
• newtype StockItemResourceCreating = StockItemResourceCreating {
  • unStockItemResourceCreating :: Integer
  }
• newtype StockItemResourceConsuming = StockItemResourceConsuming {
  • unStockItemResourceConsuming :: Integer
  }
• newtype StockItemResourceConsumed = StockItemResourceConsumed {
  • unStockItemResourceConsumed :: Integer
  }
• newtype StockItemResourceCreated = StockItemResourceCreated {
  • unStockItemResourceCreated :: Integer
  }
• newtype StockItemResourceDamaged = StockItemResourceDamaged {
  • unStockItemResourceDamaged :: Integer
  }
• newtype StockItemResourceReturned = StockItemResourceReturned {
  • unStockItemResourceReturned :: Integer
  }
• newtype StockItemResourceInReview = StockItemResourceInReview {
  • unStockItemResourceInReview :: Integer
  }
• type StockItemResourceAvailableDate = ExpectedShipDate
• newtype StockItemResourceShippedLastDay = StockItemResourceShippedLastDay {
  • unStockItemResourceShippedLastDay :: Integer
  }
• newtype StockItemResourceShippedLastWeek = StockItemResourceShippedLastWeek {
  • unStockItemResourceShippedLastWeek :: Integer
  }
• newtype StockItemResourceShippedLast4Weeks = StockItemResourceShippedLast4Weeks {
  • unStockItemResourceShippedLast4Weeks :: Integer
  }
• newtype StockItemResourceOrderedLastDay = StockItemResourceOrderedLastDay {
  • unStockItemResourceOrderedLastDay :: Integer
  }
• newtype StockItemResourceOrderedLastWeek = StockItemResourceOrderedLastWeek {
  • unStockItemResourceOrderedLastWeek :: Integer
  }
• newtype StockItemResourceOrderedLast4Weeks = StockItemResourceOrderedLast4Weeks {
  • unStockItemResourceOrderedLast4Weeks :: Integer
  }
• data IsBundle
  • = Bundle
  • | NotBundle
• data IsAlias
  • = Alias
  • | NotAlias
• type Host = Text
• data ShipwireHost
  • = ShipwireProduction
  • | ShipwireSandbox
• hostUri :: ShipwireHost -> Text
• data ShipwireConfig = ShipwireConfig {
  • host :: ShipwireHost
  • email :: Username
  • pass :: Password
  }
• prodEnvConfig :: IO ShipwireConfig
• sandboxEnvConfig :: IO ShipwireConfig
• data Params b c
  • = Query TupleBS8
  • | Body ByteString
• type TupleBS8 = (ByteString, ByteString)
• (-&-) :: ShipwireHasParam request param => ShipwireRequest request b c -> param -> ShipwireRequest request b c
• filterBody :: [Params b c] -> ByteString
• filterQuery :: [Params (ByteString, ByteString) c] -> [(ByteString, ByteString)]
• data CreateReceivingRequest
• data GetReceivingsRequest
• newtype UpdatedAfter = UpdatedAfter {
  • updatedAfter :: UTCTime
  }
• newtype ReceivingStatusParams = ReceivingStatusParams {
  • statusParam :: [ReceivingStatusParam]
  }
• data ReceivingStatusParam
  • = StatusProcessed
  • | StatusCanceled
  • | StatusCompleted
  • | StatusDelivered
  • | StatusReturned
  • | StatusSubmitted
  • | StatusHeld
  • | StatusTracked
• statusParamToBS8 :: ReceivingStatusParam -> ByteString
• newtype OrderNoParam = OrderNoParam {
  • orderNoParam :: [Text]
  }
• newtype OrderIdParam = OrderIdParam {
  • orderIdParam :: [Text]
  }
• newtype ExternalIdParam = ExternalIdParam {
  • externalIdParam :: [Text]
  }
• newtype TransactionIdParam = TransactionIdParam {
  • transactionIdParam :: [Text]
  }
• newtype ExpandReceivingsParam = ExpandReceivingsParam {
  • expandReceivingsParam :: [ExpandReceivings]
  }
• data ExpandReceivings
  • = ExpandHolds
  • | ExpandInstructionsRecipients
  • | ExpandItems
  • | ExpandShipments
  • | ExpandLabels
  • | ExpandTrackings
  • | ExpandAll
• expandReceivingsToBS8 :: ExpandReceivings -> ByteString
• newtype CommerceNameParam = CommerceNameParam {
  • commerceNameParam :: [Text]
  }
• type CreateReceivingResponse = ReceivingsResponse
• type GetReceivingsResponse = ReceivingsResponse
• data ReceivingsResponse = ReceivingsResponse {
  • receivingsResponseResourceLocation :: ResponseResourceLocation
  • receivingsResponseStatus :: ResponseStatus
  • receivingsResponseMessage :: ResponseMessage
  • receivingsResponseWarnings :: Maybe ResponseWarnings
  • receivingsResponseErrors :: Maybe ResponseErrors
  • receivingsResponseResource :: ReceivingsResource
  }
• data ReceivingsResource = ReceivingsResource {
  • receivingsResponseNext :: Maybe ResponseNext
  • receivingsResponseOffset :: ResponseOffset
  • receivingsResponsePrevious :: Maybe ResponsePrevious
  • receivingsResponseTotal :: ResponseTotal
  • receivingsResponseItems :: ReceivingsItems
  }
• newtype ReceivingsItems = ReceivingsItems {
  • unReceivingsItems :: [ReceivingsItem]
  }
• data ReceivingsItem = ReceivingsItem {
  • receivingsItemResourceLocation :: Maybe ResponseResourceLocation
  • receivingsItemResource :: ReceivingsItemResource
  }
• data ReceivingsItemResource = ReceivingsItemResource {
  • rirId :: Id
  • rirExternalId :: Maybe ExternalId
  • rirOrderNo :: Maybe OrderNo
  • rirTransactionId :: TransactionId
  • rirExpectedDate :: Maybe ExpectedDate
  • rirCommerceName :: CommerceName
  • rirLastUpdatedDate :: LastUpdatedDate
  • rirStatus :: ItemResourceStatus
  • rirHolds :: ItemResourceHolds
  • rirItems :: ItemResourceItems
  • rirTrackings :: ItemResourceTrackings
  • rirShipments :: ItemResourceShipments
  • rirLabels :: ItemResourceLabels
  • rirOptions :: ItemResourceOptions
  • rirArrangement :: ItemResourceArrangement
  • rirShipFrom :: ItemResourceShipFrom
  • rirEvents :: ItemResourceEvents
  • rirRouting :: ItemResourceRouting
  • rirInstructionsRecipients :: ItemResourceInstructionsRecipients
  }
• data ItemResourceInstructionsRecipients = ItemResourceInstructionsRecipients {
  • irirResource :: Maybe ItemResourceInstructionsRecipientsResource
  • irirResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceInstructionsRecipientsResource = ItemResourceInstructionsRecipientsResource {
  • irirrItems :: ItemResourceInstructionsRecipientsResourceItems
  • irirrNext :: Maybe ResponseNext
  • irirrOffset :: ResponseOffset
  • irirrPrevious :: Maybe ResponsePrevious
  • irirrTotal :: ResponseTotal
  }
• newtype ItemResourceInstructionsRecipientsResourceItems = ItemResourceInstructionsRecipientsResourceItems {
  • iririItems :: [ItemResourceInstructionsRecipientsItem]
  }
• data ItemResourceInstructionsRecipientsItem = ItemResourceInstructionsRecipientsItem {
  • iririResource :: ItemResourceInstructionsRecipientsItemResource
  • iririResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceInstructionsRecipientsItemResource = ItemResourceInstructionsRecipientsItemResource {
  • iririrEmail :: Email
  • iririrName :: Name
  • iririrNote :: Maybe Note
  }
• data ItemResourceRouting = ItemResourceRouting {
  • irrResource :: ItemResourceRoutingResource
  • irrResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceRoutingResource = ItemResourceRoutingResource {
  • irrrOriginLatitude :: Latitude
  • irrrOriginLongitude :: Longitude
  • irrrWarehouseExternalId :: Maybe WarehouseExternalId
  • irrrWarehouseId :: WarehouseId
  • irrrWarehouseName :: WarehouseName
  • irrrWarehouseRegion :: WarehouseRegion
  }
• newtype Latitude = Latitude {
  • unLatitude :: Double
  }
• type Longitude = Latitude
• newtype ExpectedDate = ExpectedDate {
  • unExpectedDate :: UTCTime
  }
• type LastUpdatedDate = ExpectedShipDate
• data ItemResourceEvents = ItemResourceEvents {
  • ireResource :: ItemResourceEventsResource
  • ireResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceEventsResource = ItemResourceEventsResource {
  • irerCreatedDate :: CreatedDate
  • irerPickedUpDate :: Maybe PickedUpDate
  • irerSubmittedDate :: Maybe SubmittedDate
  • irerProcessedDate :: Maybe ProcessedDate
  • irerCompletedDate :: Maybe CompletedDate
  • irerExpectedDate :: Maybe ExpectedDate
  • irerDeliveredDate :: Maybe DeliveredDate
  • irerCancelledDate :: Maybe CancelledDate
  • irerReturnedDate :: Maybe ReturnedDate
  • irerLastManualUpdateDate :: Maybe LastManualUpdateDate
  }
• type CreatedDate = ExpectedShipDate
• type PickedUpDate = ExpectedShipDate
• type SubmittedDate = ExpectedShipDate
• type ProcessedDate = ExpectedShipDate
• type CompletedDate = ExpectedShipDate
• type CancelledDate = ExpectedShipDate
• type ReturnedDate = ExpectedShipDate
• type LastManualUpdateDate = ExpectedShipDate
• data ItemResourceShipFrom = ItemResourceShipFrom {
  • irsfResource :: ItemResourceShipFromResource
  • irsfResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceShipFromResource = ItemResourceShipFromResource {
  • irsfrEmail :: Maybe Email
  • irsfrName :: Maybe Name
  • irsfrAddress1 :: Maybe AddressLine
  • irsfrAddress2 :: Maybe AddressLine
  • irsfrAddress3 :: Maybe AddressLine
  • irsfrCity :: Maybe City
  • irsfrState :: Maybe State
  • irsfrPostalCode :: Maybe PostalCode
  • irsfrCountry :: Maybe Country
  • irsfrPhone :: Maybe Phone
  }
• data ItemResourceArrangement = ItemResourceArrangement {
  • iraResource :: ItemResourceArrangementResource
  • iraResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceArrangementResource = ItemResourceArrangementResource {
  • irarContact :: Contact
  • irarPhone :: Phone
  • irarType :: ArrangementType
  }
• data ItemResourceOptions = ItemResourceOptions {
  • iroResource :: ItemResourceOptionsResource
  • iroResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceOptionsResource = ItemResourceOptionsResource {
  • irorWarehouseExternalId :: Maybe WarehouseExternalId
  • irorWarehouseId :: WarehouseId
  • irorWarehouseRegion :: WarehouseRegion
  }
• data ItemResourceLabels = ItemResourceLabels {
  • irlResource :: Maybe ItemResourceLabelsResource
  • irlResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceLabelsResource = ItemResourceLabelsResource {
  • irlrItems :: ItemResourceLabelsResourceItems
  • irlrNext :: Maybe ResponseNext
  • irlrOffset :: ResponseOffset
  • irlrPrevious :: Maybe ResponsePrevious
  • irlrTotal :: ResponseTotal
  }
• newtype ItemResourceLabelsResourceItems = ItemResourceLabelsResourceItems {
  • irlriItems :: [ItemResourceLabelsResourceItem]
  }
• data ItemResourceLabelsResourceItem = ItemResourceLabelsResourceItem {
  • irlriResource :: ItemResourceLabelsResourceItemResource
  • irlriResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceLabelsResourceItemResource = ItemResourceLabelsResourceItemResource {
  • irlrirLabelId :: LabelId
  • irlrirOrderId :: OrderId
  • irlrirOrderExternalId :: OrderExternalId
  }
• type LabelId = Id
• type OrderId = Id
• type OrderExternalId = ExternalId
• newtype ItemResourceStatus = ItemResourceStatus {
  • unItemResourceStatus :: Text
  }
• data ItemResourceShipments = ItemResourceShipments {
  • irsResource :: Maybe ItemResourceShipmentsResource
  • irsResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceShipmentsResource = ItemResourceShipmentsResource {
  • irsrItems :: ItemResourceShipmentsResourceItems
  • irsrNext :: Maybe ResponseNext
  • irsrOffset :: ResponseOffset
  • irsrPrevious :: Maybe ResponsePrevious
  • irsrTotal :: ResponseTotal
  }
• newtype ItemResourceShipmentsResourceItems = ItemResourceShipmentsResourceItems {
  • irsriItems :: [ItemResourceShipmentsResourceItem]
  }
• data ItemResourceShipmentsResourceItem = ItemResourceShipmentsResourceItem {
  • irsriResource :: ItemResourceShipmentsResourceItemResource
  • irsriResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceShipmentsResourceItemResource = ItemResourceShipmentsResourceItemResource {
  • irsrirShipmentId :: ShipmentId
  • irsrirType :: Type
  • irsrirHeight :: Maybe TextHeight
  • irsrirLength :: Maybe TextLength
  • irsrirWeight :: Maybe TextWeight
  • irsrirWidth :: Maybe TextWidth
  }
• type ShipmentId = Id
• newtype TextHeight = TextHeight {
  • unTextHeight :: Text
  }
• newtype TextLength = TextLength {
  • unTextLength :: Text
  }
• newtype TextWeight = TextWeight {
  • unTextWeight :: Text
  }
• newtype TextWidth = TextWidth {
  • unTextWidth :: Text
  }
• data ItemResourceTrackings = ItemResourceTrackings {
  • irtResource :: Maybe ItemResourceTrackingsResource
  • irtResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceTrackingsResource = ItemResourceTrackingsResource {
  • irtrItems :: ItemResourceTrackingsResourceItems
  • irtrNext :: Maybe ResponseNext
  • irtrOffset :: ResponseOffset
  • irtrPrevious :: Maybe ResponsePrevious
  • irtrTotal :: ResponseTotal
  }
• newtype ItemResourceTrackingsResourceItems = ItemResourceTrackingsResourceItems {
  • irtriItems :: [ItemResourceTrackingsResourceItem]
  }
• data ItemResourceTrackingsResourceItem = ItemResourceTrackingsResourceItem {
  • irtriResource :: ItemResourceTrackingsResourceItemResource
  • irtriResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceTrackingsResourceItemResource = ItemResourceTrackingsResourceItemResource {
  • irtrirId :: Id
  • irtrirOrderExternalId :: Maybe OrderExternalId
  • irtrirOrderId :: OrderId
  • irtrirTracking :: Tracking
  • irtrirCarrier :: CarrierName
  • irtrirContact :: Maybe Contact
  • irtrirPhone :: Maybe Phone
  • irtrirUrl :: Maybe URL
  • irtrirSummary :: Maybe Summary
  • irtrirSummaryDate :: Maybe SummaryDate
  • irtrirTrackedDate :: Maybe TrackedDate
  • irtrirDeliveredDate :: Maybe DeliveredDate
  }
• type TrackedDate = ExpectedShipDate
• type DeliveredDate = ExpectedShipDate
• newtype Summary = Summary {
  • unSummary :: Text
  }
• type SummaryDate = ExpectedShipDate
• newtype URL = URL {
  • unURL :: Text
  }
• data ItemResourceItems = ItemResourceItems {
  • iriResource :: Maybe ItemResourceItemsResource
  • iriResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceItemsResource = ItemResourceItemsResource {
  • irirItems :: ItemResourceItemsResourceItems
  • irirNext :: Maybe ResponseNext
  • irirOffset :: ResponseOffset
  • irirPrevious :: Maybe ResponsePrevious
  • irirTotal :: ResponseTotal
  }
• newtype ItemResourceItemsResourceItems = ItemResourceItemsResourceItems {
  • iririsItems :: [ItemResourceItemsResourceItem]
  }
• data ItemResourceItemsResourceItem = ItemResourceItemsResourceItem {
  • iririsResource :: ItemResourceItemsResourceItemResource
  • iririsResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceItemsResourceItemResource = ItemResourceItemsResourceItemResource {
  • iririrOrderExternalId :: Maybe OrderExternalId
  • iririrOrderId :: OrderId
  • iririrProductExternalId :: Maybe ProductExternalId
  • iririrProductId :: ProductId
  • iririrQuantity :: Quantity
  • iririrSku :: SKU
  • iririrExpected :: Expected
  • iririrPending :: Pending
  • iririrGood :: Good
  • iririrInReview :: InReview
  • iririrDamaged :: Damaged
  }
• newtype Expected = Expected {
  • unExpected :: Integer
  }
• type Pending = StockItemResourcePending
• type Good = StockItemResourceGood
• type InReview = StockItemResourceInReview
• data ItemResourceHolds = ItemResourceHolds {
  • irhResource :: Maybe ItemResourceHoldsResource
  • irhResourceLocation :: ResponseResourceLocation
  }
• data ItemResourceHoldsResource = ItemResourceHoldsResource {
  • irhrItems :: ItemResourceHoldsResourceItems
  • irhrNext :: Maybe ResponseNext
  • irhrOffset :: ResponseOffset
  • irhrPrevious :: Maybe ResponsePrevious
  • irhrTotal :: ResponseTotal
  }
• newtype ItemResourceHoldsResourceItems = ItemResourceHoldsResourceItems {
  • irhriItems :: [ItemResourceHoldsResourceItem]
  }
• data ItemResourceHoldsResourceItem = ItemResourceHoldsResourceItem {
  • irhriResource :: ItemResourceHoldsResourceItemResource
  • irhriResourceLocation :: Maybe ResponseResourceLocation
  }
• data ItemResourceHoldsResourceItemResource = ItemResourceHoldsResourceItemResource {
  • irhrirAppliedDate :: AppliedDate
  • irhrirClearedDate :: Maybe ClearedDate
  • irhrirDescription :: Description
  • irhrirExternalOrderId :: Maybe ExternalOrderId
  • irhrirId :: Id
  • irhrirOrderId :: OrderId
  • irhrirType :: Type
  }
• type ExternalOrderId = ExternalId
• newtype Description = Description {
  • unDescription :: Text
  }
• type ClearedDate = ExpectedShipDate
• type AppliedDate = ExpectedShipDate
• newtype ItemStatus = ItemStatus {
  • unItemStatus :: Text
  }
• newtype CommerceName = CommerceName {
  • unCommerceName :: Text
  }
• type TransactionId = ExternalId
• data CreateReceiving = CreateReceiving {
  • createReceivingExternalId :: Maybe ExternalId
  • createReceivingOrderNo :: Maybe OrderNo
  • createReceivingExpectedDate :: Maybe ExpectedDate
  • createReceivingOptions :: ReceivingOptions
  • createReceivingArrangement :: ReceivingArrangement
  • createReceivingShipments :: ReceivingShipments
  • createReceivingLabels :: Maybe ReceivingLabels
  • createReceivingTrackings :: Maybe ReceivingTrackings
  • createReceivingItems :: ReceivingItems
  • createReceivingShipFrom :: ReceivingShipFrom
  • createReceivingInstructionsRecipients :: Maybe ReceivingInstructionsRecipients
  }
• newtype OrderNo = OrderNo {
  • unOrderNo :: Text
  }
• data ReceivingOptions = ReceivingOptions {
  • ropWarehouseId :: Maybe WarehouseId
  • ropWarehouseExternalId :: Maybe WarehouseExternalId
  • ropWarehouseRegion :: Maybe WarehouseRegion
  }
• newtype WarehouseId = WarehouseId {
  • unWarehouseId :: Integer
  }
• newtype WarehouseExternalId = WarehouseExternalId {
  • unWarehouseExternalId :: Text
  }
• data ReceivingArrangement = ReceivingArrangement {
  • rapType :: ArrangementType
  • rapContact :: Maybe Contact
  • rapPhone :: Maybe Phone
  }
• newtype Contact = Contact {
  • unContact :: Text
  }
• newtype Phone = Phone {
  • unPhone :: Text
  }
• newtype Type = Type {
  • unType :: Text
  }
• data ArrangementType
  • = ArrangementTypeNone
  • | ArrangementTypeOverseas
  • | ArrangementTypeLabel
  • | ArrangementTypePickup
• newtype ReceivingShipments = ReceivingShipments {
  • rShipments :: [ReceivingShipment]
  }
• data ReceivingShipment = ReceivingShipment {
  • rsiLength :: Maybe Length
  • rsiWidth :: Maybe Width
  • rsiHeight :: Maybe Height
  • rsiWeight :: Maybe Weight
  • rsiType :: Type
  }
• newtype ReceivingLabels = ReceivingLabels {
  • rLabels :: [ReceivingLabel]
  }
• data ReceivingLabel = ReceivingLabel {
  • rlLabelId :: Maybe LabelId
  • rlOrderId :: Maybe OrderId
  • rlOrderExternalId :: Maybe OrderExternalId
  }
• newtype ReceivingTrackings = ReceivingTrackings {
  • rTrackings :: [ReceivingTracking]
  }
• data ReceivingTracking = ReceivingTracking {
  • rtTracking :: Tracking
  • rtCarrier :: Maybe CarrierName
  • rtContact :: Maybe Contact
  • rtPhone :: Maybe Phone
  }
• newtype Tracking = Tracking {
  • unTracking :: Text
  }
• newtype ReceivingItems = ReceivingItems {
  • rItems :: [ReceivingItem]
  }
• data ReceivingItem = ReceivingItem {
  • rSku :: SKU
  • rQuantity :: Quantity
  }
• data ReceivingShipFrom = ReceivingShipFrom {
  • rsfpEmail :: Maybe Email
  • rsfpName :: Name
  • rsfpAddress1 :: AddressLine
  • rsfpAddress2 :: Maybe AddressLine
  • rsfpCity :: City
  • rsfpState :: State
  • rsfpPostalCode :: PostalCode
  • rsfpCountry :: Country
  • rsfpPhone :: Phone
  }
• newtype Email = Email {
  • unEmail :: Text
  }
• newtype Name = Name {
  • unName :: Text
  }
• newtype State = State {
  • unState :: Text
  }
• newtype ReceivingInstructionsRecipients = ReceivingInstructionsRecipients {
  • rirsInstructionsRecipients :: [ReceivingInstructionsRecipient]
  }
• newtype Note = Note {
  • unNote :: Text
  }
• data ReceivingInstructionsRecipient = ReceivingInstructionsRecipient {
  • rirEmail :: Email
  • rirName :: Maybe Name
  • rirNote :: Maybe Note
  }
• data GetReceivingRequest
• data ReceivingResponse = ReceivingResponse {
  • receivingResponseStatus :: ResponseStatus
  • receivingResponseMessage :: ResponseMessage
  • receivingResponseWarnings :: Maybe ResponseWarnings
  • receivingResponseErrors :: Maybe ResponseErrors
  • receivingResponseResourceLocation :: Maybe ResponseResourceLocation
  • receivingResponseResource :: ReceivingResource
  }
• newtype ReceivingId = ReceivingId {
  • unReceivingId :: Text
  }
• getReceivingId :: ReceivingId -> Text
• data ModifyReceivingRequest
• type ModifyReceiving = CreateReceiving
• data SimpleResponse = SimpleResponse {
  • status :: ResponseStatus
  • resourceLocation :: Maybe ResponseResourceLocation
  • message :: ResponseMessage
  • warnings :: Maybe ResponseWarnings
  • errors :: Maybe ResponseErrors
  }
• data CancelReceivingRequest
• type CancelReceivingResponse = SimpleResponse
• data CancelReceivingLabelsRequest
• type CancelReceivingLabelsResponse = CancelReceivingResponse
• data GetReceivingHoldsRequest
• data GetReceivingHoldsResponse = GetReceivingHoldsResponse {
  • grhrStatus :: ResponseStatus
  • grhrResourceLocation :: ResponseResourceLocation
  • grhrResource :: ItemResourceHoldsResource
  • grhrMessage :: ResponseMessage
  • grhrWarnings :: Maybe ResponseWarnings
  • grhrErrors :: Maybe ResponseErrors
  }
• data IncludeClearedParam
  • = IncludeCleared
  • | DontIncludeCleared
• data GetReceivingInstructionsRecipientsRequest
• data GetReceivingInstructionsRecipientsResponse = GetReceivingInstructionsRecipientsResponse {
  • grirrStatus :: ResponseStatus
  • grirrResourceLocation :: ResponseResourceLocation
  • grirrResource :: ItemResourceInstructionsRecipientsResource
  • grirrMessage :: ResponseMessage
  • grirrWarnings :: Maybe ResponseWarnings
  • grirrErrors :: Maybe ResponseErrors
  }
• data GetReceivingItemsRequest
• data GetReceivingItemsResponse = GetReceivingItemsResponse {
  • grirStatus :: ResponseStatus
  • grirResourceLocation :: ResponseResourceLocation
  • grirResource :: ItemResourceItemsResource
  • grirMessage :: ResponseMessage
  • grirWarnings :: Maybe ResponseWarnings
  • grirErrors :: Maybe ResponseErrors
  }
• data GetReceivingShipmentsRequest
• data GetReceivingShipmentsResponse = GetReceivingShipmentsResponse {
  • grsrStatus :: ResponseStatus
  • grsrResourceLocation :: ResponseResourceLocation
  • grsrResource :: ItemResourceShipmentsResource
  • grsrMessage :: ResponseMessage
  • grsrWarnings :: Maybe ResponseWarnings
  • grsrErrors :: Maybe ResponseErrors
  }
• data GetReceivingTrackingsRequest
• data GetReceivingTrackingsResponse = GetReceivingTrackingsResponse {
  • grtrStatus :: ResponseStatus
  • grtrResourceLocation :: ResponseResourceLocation
  • grtrResource :: ItemResourceTrackingsResource
  • grtrMessage :: ResponseMessage
  • grtrWarnings :: Maybe ResponseWarnings
  • grtrErrors :: Maybe ResponseErrors
  }
• data GetReceivingLabelsRequest
• data GetReceivingLabelsResponse = GetReceivingLabelsResponse {
  • grlrStatus :: ResponseStatus
  • grlrResourceLocation :: ResponseResourceLocation
  • grlrResource :: ItemResourceLabelsResource
  • grlrMessage :: ResponseMessage
  • grlrWarnings :: Maybe ResponseWarnings
  • grlrErrors :: Maybe ResponseErrors
  }
• data GetProductsRequest
• data GetProductsResponse = GetProductsResponse {
  • gprStatus :: ResponseStatus
  • gprResourceLocation :: ResponseResourceLocation
  • gprMessage :: ResponseMessage
  • gprResource :: GetProductsResponseResource
  • gprWarnings :: Maybe ResponseWarnings
  • gprErrors :: Maybe ProductError
  }
• data GetProductsResponseResource = GetProductsResponseResource {
  • gprrPrevious :: Maybe ResponsePrevious
  • gprrNext :: Maybe ResponseNext
  • gprrTotal :: ResponseTotal
  • gprrOffset :: ResponseOffset
  • gprrItems :: GetProductsResponseResourceItems
  }
• newtype GetProductsResponseResourceItems = GetProductsResponseResourceItems {
  • gprriItems :: [GetProductsResponseResourceItem]
  }
• data GetProductsResponseResourceItem = GetProductsResponseResourceItem {
  • gprriResourceLocation :: ResponseResourceLocation
  • gprriResource :: ProductsWrapper
  }
• data ProductsWrapper
  • = PwBaseProduct BaseProductResponseResource
  • | PwMarketingInsert MarketingInsertResponseResource
  • | PwVirtualKit VirtualKitResponseResource
  • | PwKit KitResponseResource
• data BaseProductResponseResource = BaseProductResponseResource {
  • bprClassification :: Classification
  • bprBatteryConfiguration :: Maybe BatteryConfiguration
  • bprMasterCase :: Maybe BaseProductResponseMasterCase
  • bprItemCount :: ItemCount
  • bprId :: Id
  • bprSku :: SKU
  • bprArchivedDate :: Maybe ArchivedDate
  • bprEnqueuedDimensions :: EnqueuedDimensions
  • bprDimensions :: Dimensions
  • bprInnerPack :: Maybe InnerPack
  • bprPallet :: Maybe Pallet
  • bprExternalId :: Maybe ExternalId
  • bprAlternateNames :: AlternateNamesResponse
  • bprValues :: ValuesResponse
  • bprStatus :: Status
  • bprCategory :: Maybe Category
  • bprVendorId :: Maybe VendorId
  • bprVendorExternalid :: Maybe VendorExternalId
  • bprDescription :: Description
  • bprFlags :: Flags
  • bprCreationDate :: CreationDate
  • bprHsCode :: Maybe HsCode
  • bprCountryOfOrigin :: Maybe CountryOfOrigin
  • bprStorageConfiguration :: StorageConfiguration
  • bprTechnicalData :: Maybe TechnicalData
  }
• data TechnicalData = TechnicalData {
  • tdResourceLocation :: Maybe ResponseResourceLocation
  • tdResource :: Maybe TechnicalDataResource
  }
• data TechnicalDataResource = TechnicalDataResource {
  • tdrCapacityUnit :: Maybe CapacityUnit
  • tdrCapacity :: Maybe CapacityResponse
  • tdrBatteryWeight :: Maybe BatteryWeightResponse
  • tdrNumberOfCells :: Maybe NumberOfCells
  • tdrType :: Maybe BatteryType
  • tdrNumberOfBatteries :: Maybe NumberOfBatteries
  • tdrProductId :: Maybe ProductId
  }
• newtype NumberOfBatteries = NumberOfBatteries {
  • unNumberOfBatteries :: Integer
  }
• newtype BatteryType = BatteryType {
  • unBatteryType :: Text
  }
• newtype NumberOfCells = NumberOfCells {
  • unNumberOfCells :: Integer
  }
• newtype BatteryWeightResponse = BatteryWeightResponse {
  • unBatteryWeightR :: Text
  }
• newtype BatteryWeight = BatteryWeight {
  • unBatteryWeight :: Integer
  }
• newtype CapacityResponse = CapacityResponse {
  • unCapacityR :: Text
  }
• newtype Capacity = Capacity {
  • unCapacity :: Integer
  }
• newtype CapacityUnit = CapacityUnit {
  • unCapacityUnit :: Text
  }
• data StorageConfiguration
  • = IndividualItemConfiguration
  • | InnerPackConfiguration
  • | MasterCaseConfiguration
  • | PalletConfiguration
  • | KitConfiguration
• newtype CountryOfOrigin = CountryOfOrigin {
  • unCountryOfOrigin :: Text
  }
• newtype HsCode = HsCode {
  • unHsCode :: Text
  }
• type CreationDate = ExpectedDate
• data Flags = Flags {
  • fResourceLocation :: Maybe ResponseResourceLocation
  • fResource :: Maybe FlagsResource
  }
• data FlagsResource = FlagsResource {
  • frIsMedia :: IsMedia
  • frIsDeletable :: IsDeletable
  • frHasPallet :: Maybe HasPallet
  • frIsPackagedReadyToShip :: IsPackagedReadyToShip
  • frHasMasterCase :: Maybe HasMasterCase
  • frIsFragile :: IsFragile
  • frIsArchivable :: IsArchivable
  • frIsLiquid :: IsLiquid
  • frIsDangerous :: Maybe IsDangerous
  • frIsPerishable :: IsPerishable
  • frHasEditRestrictions :: HasEditRestrictions
  • frHasInnerPack :: Maybe HasInnerPack
  • frIsAdult :: IsAdult
  }
• data IsAdult
  • = Adult
  • | NotAdult
• data HasInnerPack
  • = HasInnerPack
  • | NoInnerPack
• data HasEditRestrictions
  • = EditRestrictions
  • | NoEditRestrictions
• data IsPerishable
  • = Perishable
  • | NotPerishable
• data IsDangerous
  • = Dangerous
  • | NotDangerous
• data IsLiquid
  • = Liquid
  • | NotLiquid
• data IsArchivable
  • = Archivable
  • | NotArchivable
• data IsFragile
  • = Fragile
  • | NotFragile
• data HasMasterCase
  • = HasMasterCase
  • | NoMasterCase
• data HasPallet
  • = HasPallet
  • | NoPallet
• data IsDeletable
  • = Deletable
  • | NotDeletable
• data IsMedia
  • = Media
  • | NotMedia
• newtype Category = Category {
  • unCategory :: Text
  }
• newtype Status = Status {
  • unStatus :: Text
  }
• data AlternateNamesResponse = AlternateNamesResponse {
  • anResourceLocation :: Maybe ResponseResourceLocation
  • anResource :: Maybe AlternateNamesResponseResource
  }
• data AlternateNamesResponseResource = AlternateNamesResponseResource {
  • anrPrevious :: Maybe ResponsePrevious
  • anrNext :: Maybe ResponseNext
  • anrTotal :: ResponseTotal
  • anrItems :: AlternateNamesResponseResourceItems
  • anrOffset :: ResponseOffset
  }
• newtype AlternateNamesResponseResourceItems = AlternateNamesResponseResourceItems {
  • anriItems :: [AlternateNamesResponseResourceItem]
  }
• data AlternateNamesResponseResourceItem = AlternateNamesResponseResourceItem {
  • anriResourceLocation :: Maybe ResponseResourceLocation
  • anriResource :: AlternateNamesResponseResourceItemResource
  }
• data AlternateNamesResponseResourceItemResource = AlternateNamesResponseResourceItemResource {
  • anrirExternalid :: Maybe ExternalId
  • anrirName :: Name
  • anrirProductId :: ProductId
  }
• data Pallet = Pallet {
  • pResourceLocation :: Maybe ResponseResourceLocation
  • pResource :: Maybe PalletResource
  }
• type PalletResource = BaseProductResponseMasterCaseResource
• data InnerPack = InnerPack {
  • ipResourceLocation :: Maybe ResponseResourceLocation
  • ipResource :: Maybe InnerPackResource
  }
• type InnerPackResource = BaseProductResponseMasterCaseResource
• data EnqueuedDimensions = EnqueuedDimensions {
  • edResourceLocation :: Maybe ResponseResourceLocation
  • edResource :: Maybe EnqueuedDimensionsResource
  }
• data EnqueuedDimensionsResource = EnqueuedDimensionsResource {
  • edrPrevious :: Maybe ResponsePrevious
  • edrNext :: Maybe ResponseNext
  • edrTotal :: ResponseTotal
  • edrItems :: Maybe Array
  • edrOffset :: ResponseOffset
  }
• newtype ItemCount = ItemCount {
  • unItemCount :: Integer
  }
• type ArchivedDate = ExpectedDate
• data Classification
  • = BaseProductClassification
  • | MarketingInsertClassification
  • | VirtualKitClassification
  • | KitClassification
• data BatteryConfiguration
  • = NoBatteryConfiguration
  • | IsBatteryConfiguration
  • | HasLooseBatteryConfiguration
• data BaseProductResponseMasterCase = BaseProductResponseMasterCase {
  • mcResourceLocation :: Maybe ResponseResourceLocation
  • mcResource :: Maybe BaseProductResponseMasterCaseResource
  }
• data BaseProductResponseMasterCaseResource = BaseProductResponseMasterCaseResource {
  • mcrSku :: Maybe SKU
  • mcrDimensions :: Maybe Dimensions
  • mcrValues :: Maybe ValuesResource
  • mcrExternalId :: Maybe ExternalId
  • mcrIndividualItemsPerCase :: Maybe IndividualItemsPerCase
  • mcrFlags :: Maybe MasterCaseFlags
  • mcrProductId :: Maybe ProductId
  • mcrDescription :: Maybe Description
  }
• data Dimensions = Dimensions {
  • dResourceLocation :: Maybe ResponseResourceLocation
  • dResource :: Maybe DimensionsResource
  }
• data DimensionsResource = DimensionsResource {
  • drWeight :: DimensionsWeight
  • drWeightUnit :: WeightUnit
  • drHeight :: DimensionsHeight
  • drHeightUnit :: HeightUnit
  • drWidth :: DimensionsWidth
  • drWidthUnit :: WidthUnit
  • drLength :: DimensionsLength
  • drLengthUnit :: LengthUnit
  }
• newtype DimensionsWeight = DimensionsWeight {
  • unDimensionsWeight :: Text
  }
• type WeightUnit = PieceWeightUnits
• newtype DimensionsHeight = DimensionsHeight {
  • unDimensionsHeight :: Text
  }
• type HeightUnit = PieceHeightUnits
• newtype DimensionsWidth = DimensionsWidth {
  • unDimensionsWidth :: Text
  }
• type WidthUnit = PieceWidthUnits
• newtype DimensionsLength = DimensionsLength {
  • unDimensionsLength :: Text
  }
• type LengthUnit = PieceLengthUnits
• data ValuesResponse = ValuesResponse {
  • vrResourceLocation :: Maybe ResponseResourceLocation
  • vrResource :: Maybe ValuesResource
  }
• data ValuesResource = ValuesResource {
  • vrCostValueCurrency :: Maybe CostValueCurrency
  • vrWholesaleValue :: Maybe WholesaleValueResponse
  • vrCostValue :: Maybe CostValueResponse
  • vrWholesaleValueCurrency :: Maybe WholesaleValueCurrency
  • vrRetailValue :: Maybe RetailValueResponse
  • vrRetailValueCurrency :: Maybe RetailValueCurrency
  }
• data Values = Values {
  • vCostValue :: CostValue
  • vWholesaleValue :: Maybe WholesaleValue
  • vRetailValue :: RetailValue
  • vCostCurrency :: Maybe CostCurrency
  • vWholesaleCurrency :: Maybe WholesaleCurrency
  • vRetailCurrency :: Maybe RetailCurrency
  }
• newtype CostValueCurrency = CostValueCurrency {
  • unCostValueCurrency :: Text
  }
• newtype WholesaleValueCurrency = WholesaleValueCurrency {
  • unWholesaleValueCurrency :: Text
  }
• newtype RetailValueCurrency = RetailValueCurrency {
  • unRetailValueCurrency :: Text
  }
• newtype CostValueResponse = CostValueResponse {
  • unCostValueR :: Text
  }
• newtype CostValue = CostValue {
  • unCostValue :: Centi
  }
• newtype IndividualItemsPerCase = IndividualItemsPerCase {
  • unIndividualItemsPerCase :: Integer
  }
• data MasterCaseFlags = MasterCaseFlags {
  • mcfResourceLocation :: Maybe ResponseResourceLocation
  • mcfResource :: MasterCaseFlagsResource
  }
• newtype MasterCaseFlagsResource = MasterCaseFlagsResource {
  • unFlagsResource :: IsPackagedReadyToShip
  }
• data IsPackagedReadyToShip
  • = PackagedReadyToShip
  • | NotPackagedReadyToShip
• data MarketingInsertResponseResource = MarketingInsertResponseResource {
  • mirId :: Id
  • mirExternalId :: Maybe ExternalId
  • mirSku :: SKU
  • mirDescription :: Description
  • mirInclusionRuleType :: Maybe InclusionRuleType
  • mirCreationDate :: CreationDate
  • mirArchivedDate :: Maybe ArchivedDate
  • mirStatus :: Status
  • mirStorageConfiguration :: StorageConfiguration
  • mirClassificaion :: Classification
  • mirItemCount :: ItemCount
  • mirDimensions :: Dimensions
  • mirAlternateNames :: AlternateNamesResponse
  • mirFlags :: Maybe MarketingInsertFlagsResponse
  • mirInclusionRules :: Maybe InclusionRules
  • mirMasterCase :: Maybe MarketingInsertMasterCaseResponse
  }
• data MarketingInsertMasterCaseResponse = MarketingInsertMasterCaseResponse {
  • mimcResourceLocation :: Maybe ResponseResourceLocation
  • mimcResource :: Maybe MarketingInsertMasterCaseResponseResource
  }
• data MarketingInsertMasterCaseResponseResource = MarketingInsertMasterCaseResponseResource {
  • mimcrProductId :: ProductId
  • mimcrExternalId :: Maybe ExternalId
  • mimcrIndividualItemsPerCase :: IndividualItemsPerCase
  • mimcrSku :: SKU
  • mimcrDescription :: Description
  • mimcrDimensions :: Dimensions
  }
• newtype InclusionRuleType = InclusionRuleType {
  • unInclusionRuleType :: Text
  }
• data InclusionRules = InclusionRules {
  • irResourceLocation :: Maybe ResponseResourceLocation
  • irResource :: Maybe InclusionRulesResource
  }
• data InclusionRulesResource = InclusionRulesResource {
  • irrProductId :: ProductId
  • irrInsertAfterDate :: Maybe InsertAfterDate
  • irrInsertBeforeDate :: Maybe InsertBeforeDate
  • irrInsertWhenWorthValue :: InsertWhenWorthValueResponse
  • irrInsertWhenWorthValueCurrency :: InsertWhenWorthValueCurrency
  • irrInsertWhenQuantity :: InsertWhenQuantity
  • irrFlags :: Maybe InclusionRulesResourceFlags
  }
• newtype InsertAfterDate = InsertAfterDate {
  • unInsertAfterDate :: UTCTime
  }
• newtype InsertBeforeDate = InsertBeforeDate {
  • unInsertBeforeDate :: UTCTime
  }
• newtype InsertWhenWorthValueResponse = InsertWhenWorthValueResponse {
  • unInsertWhenWorthValueResponse :: Text
  }
• type InsertWhenWorthValueCurrency = CostCurrency
• newtype InsertWhenQuantity = InsertWhenQuantity {
  • unInsertWhenQuantity :: Integer
  }
• newtype InclusionRulesResourceFlags = InclusionRulesResourceFlags {
  • irrfResourceLocation :: Maybe ResponseResourceLocation
  }
• data MarketingInsertFlagsResponse = MarketingInsertFlagsResponse {
  • mifResourceLocation :: Maybe ResponseResourceLocation
  • mifResource :: Maybe MarketingInsertFlagsResponseResource
  }
• data MarketingInsertFlagsResponseResource = MarketingInsertFlagsResponseResource {
  • mifrIsPackagedReadyToShip :: IsPackagedReadyToShip
  • mifrHasMasterCase :: Maybe HasMasterCase
  • mifrIsArchivable :: IsArchivable
  • mifrIsDeletable :: IsDeletable
  • mifrHasEditRestrictions :: HasEditRestrictions
  }
• data VirtualKitResponseResource = VirtualKitResponseResource {
  • vkrId :: Id
  • vkrExternalId :: Maybe ExternalId
  • vkrClassification :: Classification
  • vkrSku :: SKU
  • vkrCreationDate :: CreationDate
  • vkrDescription :: Description
  • vkrStatus :: Status
  • vkrVirtualKitContent :: VirtualKitResponseContent
  • vkrFlags :: VirtualKitFlags
  }
• data VirtualKitResponseContent = VirtualKitResponseContent {
  • vkcResourceLocation :: ResponseResourceLocation
  • vkcResource :: Maybe VirtualKitContentResource
  }
• data VirtualKitContentResource = VirtualKitContentResource {
  • vkcrOffset :: ResponseOffset
  • vkcrTotal :: ResponseTotal
  • vkcrPrevious :: Maybe ResponsePrevious
  • vkcrNext :: Maybe ResponseNext
  • vkcrItems :: VirtualKitContentResourceItems
  }
• newtype VirtualKitContentResourceItems = VirtualKitContentResourceItems {
  • vkcriItems :: [VirtualKitContentResourceItem]
  }
• data VirtualKitContentResourceItem = VirtualKitContentResourceItem {
  • vkcriResourceLocation :: Maybe ResponseResourceLocation
  • vkcriResource :: VirtualKitContentResourceItemResource
  }
• data VirtualKitContentResourceItemResource = VirtualKitContentResourceItemResource {
  • vkcrirProductId :: ProductId
  • vkcrirExternalId :: ExternalId
  • vkcrirQuantity :: Quantity
  }
• newtype VirtualKitFlags = VirtualKitFlags {
  • vkfResourceLocation :: Maybe ResponseResourceLocation
  }
• data KitResponseResource = KitResponseResource {
  • krId :: Id
  • krExternalId :: Maybe ExternalId
  • krSku :: SKU
  • krDescription :: Description
  • krHsCode :: Maybe HsCode
  • krCountryOfOrigin :: Maybe CountryOfOrigin
  • krCreationDate :: CreationDate
  • krArchivedDate :: Maybe ArchivedDate
  • krStatus :: Status
  • krStorageConfiguration :: StorageConfiguration
  • krBatteryConfiguration :: Maybe BatteryConfiguration
  • krClassification :: Classification
  • krCategory :: Maybe Category
  • krItemCount :: ItemCount
  • krDimensions :: Dimensions
  • krValues :: ValuesResource
  • krAlternateNames :: AlternateNamesResponse
  • krKitContent :: Maybe KitResponseContent
  • krTechnicalData :: Maybe KitResponseTechnicalData
  • krFlags :: Flags
  • krEnqueuedDimensions :: EnqueuedDimensions
  • krInnerPack :: Maybe InnerPack
  • krMasterCase :: Maybe KitResponseMasterCase
  • krPallet :: Maybe Pallet
  }
• type KitResponseMasterCase = BaseProductResponseMasterCase
• data KitResponseTechnicalData = KitResponseTechnicalData {
  • ktdResourceLocation :: Maybe ResponseResourceLocation
  • ktdResource :: Maybe KitResponseTechnicalDataResource
  }
• newtype KitResponseTechnicalDataResource = KitResponseTechnicalDataResource {
  • ktdrBattery :: KitResponseTechnicalDataResourceBattery
  }
• data KitResponseTechnicalDataResourceBattery = KitResponseTechnicalDataResourceBattery {
  • ktdrbResourceLocation :: Maybe ResponseResourceLocation
  • ktdrbResource :: KitTechnicalDataResourceBatteryResource
  }
• type KitTechnicalDataResourceBatteryResource = TechnicalDataResource
• type KitResponseContent = VirtualKitResponseContent
• newtype ExpandProductsParam = ExpandProductsParam {
  • expandProductsParam :: [ExpandProducts]
  }
• data ExpandProducts
  • = ProductsExpandAll
  • | ExpandAlternateNames
  • | ExpandMasterCase
  • | ExpandEnqueuedDimensions
  • | ExpandFlags
  • | ExpandDimensions
  • | ExpandTechnicalData
  • | ExpandInnerPack
  • | ExpandPallet
  • | ExpandValues
  • | ExpandKitContent
  • | ExpandInclusionRules
  • | ExpandVirtualKitContent
• expandProductsToBS8 :: ExpandProducts -> ByteString
• data ClassificationParam
  • = ClassificationParamBaseProduct
  • | ClassificationParamKit
  • | ClassificationParamVirtualKit
  • | ClassificationParamMarketingInsert
• classificationToBS :: ClassificationParam -> ByteString
• newtype DescriptionParam = DescriptionParam {
  • unDescriptionParam :: Text
  }
• data IncludeArchived
  • = AnyArchived
  • | IncludeArchived
  • | ExcludeArchived
• includeArchivedToBS :: IncludeArchived -> ByteString
• newtype ProductStatusParams = ProductStatusParams {
  • unProductStatusParams :: [ProductStatusParam]
  }
• data ProductStatusParam
  • = NotInUse
  • | InStock
  • | OutOfStock
• productStatusParamToBS :: ProductStatusParam -> ByteString
• newtype FlowParams = FlowParams {
  • unFlowParams :: [FlowParam]
  }
• data FlowParam
  • = ManageStep
  • | KitStep
  • | VirtualKitStep
  • | OrderStep
  • | ReceivingStep
  • | QuoteStep
• flowParamToBS :: FlowParam -> ByteString
• newtype IdsParam = IdsParam {
  • unIdsParam :: [ByteString]
  }
• newtype SkusParam = SkusParam {
  • unSkusParam :: [ByteString]
  }
• data CreateProductsRequest
• type CreateProductsResponse = GetProductsResponse
• data CreateProductsWrapper
  • = CpwBaseProduct BaseProduct
  • | CpwMarketingInsert MarketingInsert
  • | CpwVirtualKit VirtualKit
  • | CpwKit Kit
• data BaseProduct = BaseProduct {
  • bpId :: Maybe Id
  • bpSku :: SKU
  • bpExternalId :: Maybe ExternalId
  • bpClassification :: Classification
  • bpDescription :: Description
  • bpHsCode :: Maybe HsCode
  • bpCountryOfOrigin :: Maybe CountryOfOrigin
  • bpCategory :: Category
  • bpBatteryConfiguration :: BatteryConfiguration
  • bpValues :: Values
  • bpAlternateNames :: Maybe BaseProductAlternateNames
  • bpDimensions :: BaseProductDimensions
  • bpTechnicalData :: Maybe BaseProductTechnicalData
  • bpFlags :: Maybe BaseProductFlags
  • bpInnerPack :: Maybe BaseProductInnerPack
  • bpMasterCase :: Maybe BaseProductMasterCase
  • bpPallet :: Maybe BaseProductPallet
  }
• data BaseProductPallet = BaseProductPallet {
  • bppIndividualItemsPerCase :: IndividualItemsPerCase
  • bppExternalid :: Maybe ExternalId
  • bppSku :: SKU
  • bppDescription :: Description
  • bppValues :: Values
  • bppDimensions :: BaseProductDimensions
  • bppFlags :: BaseProductPalletFlags
  }
• data BaseProductMasterCase = BaseProductMasterCase {
  • bpmcIndividualItemsPerCase :: IndividualItemsPerCase
  • bpmcExternalId :: Maybe ExternalId
  • bpmcSku :: SKU
  • bpmcDescription :: Description
  • bpmcValues :: Values
  • bpmcDimensions :: BaseProductDimensions
  • bpmcFlags :: BaseProductMasterCaseFlags
  }
• data BaseProductInnerPack = BaseProductInnerPack {
  • bpipIndividualItemsPerCase :: IndividualItemsPerCase
  • bpipExternalId :: Maybe ExternalId
  • bpipSku :: SKU
  • bpipDescription :: Description
  • bpipValues :: Values
  • bpipDimensions :: BaseProductDimensions
  • bpipFlags :: BaseProductInnerPackFlags
  }
• newtype BaseProductAlternateNames = BaseProductAlternateNames {
  • bpanAlternateNames :: [BaseProductAlternateName]
  }
• newtype BaseProductAlternateName = BaseProductAlternateName {
  • bpanName :: Name
  }
• data BaseProductFlags = BaseProductFlags {
  • bpfIsPackagedReadyToShip :: IsPackagedReadyToShip
  • bpfIsFragile :: IsFragile
  • bpfIsDangerous :: IsDangerous
  • bpfIsPerishable :: IsPerishable
  • bpfIsMedia :: IsMedia
  • bpfIsAdult :: IsAdult
  • bpfIsLiquid :: IsLiquid
  • bpfHasInnerPack :: HasInnerPack
  • bpfHasMasterCase :: HasMasterCase
  • bpfHasPallet :: HasPallet
  }
• newtype BaseProductPalletFlags = BaseProductPalletFlags {
  • bppfIsPackagedReadyToShip :: IsPackagedReadyToShip
  }
• newtype BaseProductMasterCaseFlags = BaseProductMasterCaseFlags {
  • bpmcfIsPackagedReadyToShip :: IsPackagedReadyToShip
  }
• newtype BaseProductInnerPackFlags = BaseProductInnerPackFlags {
  • bpipfIsPackagedReadyToShip :: IsPackagedReadyToShip
  }
• newtype BaseProductTechnicalData = BaseProductTechnicalData {
  • bptdTechnicalDataBattery :: BaseProductTechnicalDataBattery
  }
• data BaseProductTechnicalDataBattery = BaseProductTechnicalDataBattery {
  • bptdbType :: Maybe BatteryType
  • bptdbBatteryWeight :: Maybe BatteryWeight
  • bptdbNumberOfBatteries :: Maybe NumberOfBatteries
  • bptdbCapacity :: Maybe Capacity
  • bptdbNumberOfCells :: Maybe NumberOfCells
  • bptdbCapacityUnit :: Maybe CapacityUnit
  }
• data BaseProductDimensions = BaseProductDimensions {
  • bpdLength :: BaseProductLength
  • bpdWidth :: BaseProductWidth
  • bpdHeight :: BaseProductHeight
  • bpdWeight :: BaseProductWeight
  }
• newtype BaseProductLength = BaseProductLength {
  • unBaseProductLength :: Double
  }
• newtype BaseProductWidth = BaseProductWidth {
  • unBaseProductWidth :: Double
  }
• newtype BaseProductHeight = BaseProductHeight {
  • unBaseProductHeight :: Double
  }
• newtype BaseProductWeight = BaseProductWeight {
  • unBaseProductWeight :: Double
  }
• newtype RetailCurrency = RetailCurrency {
  • unRetailCurrency :: Text
  }
• newtype WholesaleCurrency = WholesaleCurrency {
  • unWholesaleCurrency :: Text
  }
• newtype RetailValue = RetailValue {
  • unRetailValue :: Centi
  }
• newtype RetailValueResponse = RetailValueResponse {
  • unRetailValueResponsee :: Text
  }
• newtype WholesaleValue = WholesaleValue {
  • unWholesaleValue :: Centi
  }
• newtype WholesaleValueResponse = WholesaleValueResponse {
  • unWholesaleValeuResponse :: Text
  }
• data MarketingInsert = MarketingInsert {
  • miId :: Maybe Id
  • miSku :: SKU
  • miExternalId :: Maybe ExternalId
  • miClassification :: Classification
  • miDescription :: Description
  • miInclusionRuleType :: InclusionRuleType
  • miAlternateNames :: Maybe MarketingInsertAlternateNames
  • miDimensions :: MarketingInsertDimensions
  • miFlags :: Maybe MarketingInsertFlags
  • miInclusionRules :: Maybe MarketingInsertInclusionRules
  • miMasterCase :: MarketingInsertMasterCase
  }
• newtype MarketingInsertAlternateNames = MarketingInsertAlternateNames {
  • unMarketingInsertAlternateNames :: [MarketingInsertAlternateName]
  }
• newtype MarketingInsertAlternateName = MarketingInsertAlternateName {
  • mianName :: Name
  }
• data MarketingInsertDimensions = MarketingInsertDimensions {
  • midLength :: MarketingInsertLength
  • midWidth :: MarketingInsertWidth
  • midHeight :: MarketingInsertHeight
  • midWeight :: MarketingInsertWeight
  }
• newtype MarketingInsertLength = MarketingInsertLength {
  • unMarketingInsertLength :: Double
  }
• newtype MarketingInsertWidth = MarketingInsertWidth {
  • unMarketingInsertWidth :: Double
  }
• newtype MarketingInsertHeight = MarketingInsertHeight {
  • unMarketingInsertHeight :: Double
  }
• newtype MarketingInsertWeight = MarketingInsertWeight {
  • unMarketingInsertWeight :: Double
  }
• data MarketingInsertInclusionRules = MarketingInsertInclusionRules {
  • miirInsertAfterDate :: Maybe InsertAfterDate
  • miirInsertBeforeDate :: Maybe InsertBeforeDate
  • miirInsertWhenWorthValue :: Maybe InsertWhenWorthValue
  • miirInsertWhenQuantity :: Maybe InsertWhenQuantity
  • miirInsertWhenWorthCurrency :: Maybe InsertWhenWorthCurrency
  }
• data ShouldNotFold
  • = ShouldNotFold
  • | ShouldFold
• newtype MarketingInsertFlags = MarketingInsertFlags {
  • mifShouldNotFold :: ShouldNotFold
  }
• newtype InsertWhenWorthValue = InsertWhenWorthValue {
  • unInsertWhenWorthValue :: Centi
  }
• newtype InsertWhenWorthCurrency = InsertWhenWorthCurrency {
  • unInsertWhenWorthCurrency :: Text
  }
• data MarketingInsertMasterCase = MarketingInsertMasterCase {
  • mimcIndividualItemsPerCase :: IndividualItemsPerCase
  • mimcSku :: SKU
  • mimcExternalId :: Maybe ExternalId
  • mimcDescription :: Description
  • mimcDimensions :: MarketingInsertMasterCaseDimensions
  }
• data MarketingInsertMasterCaseDimensions = MarketingInsertMasterCaseDimensions {
  • mimcdLength :: MarketingInsertMasterCaseDimensionsLength
  • mimcdWidth :: MarketingInsertMasterCaseDimensionsWidth
  • mimcdHeight :: MarketingInsertMasterCaseDimensionsHeight
  • mimcdWeight :: MarketingInsertMasterCaseDimensionsWeight
  }
• newtype MarketingInsertMasterCaseDimensionsHeight = MarketingInsertMasterCaseDimensionsHeight {
  • unMarketingInsertMasterCaseDimensionsHeight :: Double
  }
• newtype MarketingInsertMasterCaseDimensionsLength = MarketingInsertMasterCaseDimensionsLength {
  • unMarketingInsertMasterCaseDimensionsLength :: Double
  }
• newtype MarketingInsertMasterCaseDimensionsWidth = MarketingInsertMasterCaseDimensionsWidth {
  • unMarketingInsertMasterCaseDimensionsWidth :: Double
  }
• newtype MarketingInsertMasterCaseDimensionsWeight = MarketingInsertMasterCaseDimensionsWeight {
  • unMarketingInsertMasterCaseDimensionsWeight :: Double
  }
• newtype ProductError = ProductError {
  • unProductError :: Object
  }
• data VirtualKit = VirtualKit {
  • vkId :: Maybe Id
  • vkSku :: SKU
  • vkClassification :: Classification
  • vkDescription :: Description
  • vkVirtualKitContent :: VirtualKitContent
  }
• newtype VirtualKitContent = VirtualKitContent {
  • unVirtualKitContent :: [VirtualKitContentObject]
  }
• data VirtualKitContentObject = VirtualKitContentObject {
  • vkcoProductId :: Maybe ProductId
  • vkcoExternalId :: Maybe ExternalId
  • vkcoQuantity :: Quantity
  }
• data Kit = Kit {
  • kId :: Maybe Id
  • kSku :: SKU
  • kExternalId :: Maybe ExternalId
  • kClassification :: Classification
  • kDescription :: Description
  • kBatteryConfiguration :: BatteryConfiguration
  • kHsCode :: Maybe HsCode
  • kCountryOfOrigin :: Maybe CountryOfOrigin
  • kValues :: KitValues
  • kAlternateNames :: Maybe KitAlternateNames
  • kContent :: KitContent
  • kDimensions :: KitDimensions
  • kTechnicalData :: Maybe KitTechnicalData
  • kFlags :: Maybe KitFlags
  • kInnerPack :: Maybe KitInnerPack
  • kMasterCase :: Maybe KitMasterCase
  • kPallet :: Maybe KitPallet
  }
• data KitPallet = KitPallet {
  • kpIndividualItemsPerCase :: IndividualItemsPerCase
  • kpSku :: SKU
  • kpDescription :: Description
  • kpValues :: KitValues
  • kpDimensions :: KitDimensions
  • kpFlags :: KitPalletFlags
  }
• newtype KitPalletFlags = KitPalletFlags {
  • kpfIsPackagedReadyToShip :: IsPackagedReadyToShip
  }
• data KitMasterCase = KitMasterCase {
  • kmcIndividualItemsPerCase :: IndividualItemsPerCase
  • kmcSku :: SKU
  • kmcDescription :: Description
  • kmcValues :: KitValues
  • kmcDimensions :: KitDimensions
  • kmcFlags :: KitMasterCaseFlags
  }
• newtype KitMasterCaseFlags = KitMasterCaseFlags {
  • kmcfIsPackagedReadyToShip :: IsPackagedReadyToShip
  }
• data KitInnerPack = KitInnerPack {
  • kipIndividualItemsPerCase :: IndividualItemsPerCase
  • kipSku :: SKU
  • kipDescription :: Description
  • kipValues :: KitValues
  • kipDimensions :: KitDimensions
  • kipFlags :: KitInnerPackFlags
  }
• newtype KitInnerPackFlags = KitInnerPackFlags {
  • kipfIsPackagedReadyToShip :: IsPackagedReadyToShip
  }
• data KitFlags = KitFlags {
  • kfIsPackagedReadyToShip :: IsPackagedReadyToShip
  • kfIsFragile :: IsFragile
  • kfIsDangerous :: IsDangerous
  • kfIsPerishable :: IsPerishable
  • kfIsMedia :: IsMedia
  • kfIsAdult :: IsAdult
  • kfIsLiquid :: IsLiquid
  • kfHasBattery :: HasBattery
  • kfHasInnerPack :: HasInnerPack
  • kfHasMasterCase :: HasMasterCase
  • kfHasPallet :: HasPallet
  }
• data HasBattery
  • = HasBattery
  • | NoBattery
• newtype KitTechnicalData = KitTechnicalData {
  • ktdTechnicalDataBattery :: KitTechnicalDataBattery
  }
• data KitTechnicalDataBattery = KitTechnicalDataBattery {
  • ktdbType :: BatteryType
  • ktdbBatteryWeight :: Maybe BatteryWeight
  • ktdbNumberOfBatteries :: Maybe NumberOfBatteries
  • ktdbCapacity :: Maybe Capacity
  • ktdbNumberOfCells :: Maybe NumberOfCells
  • ktdbCapacityUnit :: Maybe CapacityUnit
  }
• data KitDimensions = KitDimensions {
  • kdLength :: KitLength
  • kdWidth :: KitWidth
  • kdHeight :: KitHeight
  • kdWeight :: KitWeight
  }
• newtype KitLength = KitLength {
  • unKitLength :: Double
  }
• newtype KitWidth = KitWidth {
  • unKitWidth :: Double
  }
• newtype KitHeight = KitHeight {
  • unKitHeight :: Double
  }
• newtype KitWeight = KitWeight {
  • unKitWeight :: Double
  }
• newtype KitContent = KitContent {
  • unKitContent :: [KitContentObject]
  }
• data KitContentObject = KitContentObject {
  • kcProductId :: Maybe ProductId
  • kcExternalId :: Maybe ExternalId
  • kcQuantity :: Quantity
  }
• newtype KitAlternateNames = KitAlternateNames {
  • kanAlternateNames :: [KitAlternateName]
  }
• newtype KitAlternateName = KitAlternateName {
  • kanAlternateName :: Name
  }
• data KitValues = KitValues {
  • kvCostValue :: CostValue
  • kvWholesaleValue :: WholesaleValue
  • kvRetailValue :: RetailValue
  • kvCostCurrency :: Maybe CostCurrency
  • kvWholesaleCurrency :: Maybe WholesaleCurrency
  • kvRetailCurrency :: Maybe RetailCurrency
  }
• utcToShipwire :: UTCTime -> Text
• data RetireProductsRequest
• data RetireProductsResponse = RetireProductsResponse {
  • rprMessage :: Message
  • rprMoreInfo :: Maybe MoreInfo
  • rprResourceLocation :: Maybe ResponseResourceLocation
  • rprStatus :: ResponseStatus
  }
• newtype ProductsToRetire = ProductsToRetire {
  • rpIds :: [Id]
  }
• newtype Message = Message {
  • unMessage :: Text
  }
• newtype MoreInfo = MoreInfo {
  • miItems :: [MoreInfoItems]
  }
• newtype MoreInfoItems = MoreInfoItems {
  • miiItems :: [MoreInfoItem]
  }
• data MoreInfoItem = MoreInfoItem {
  • miiId :: Id
  • miiExternalId :: Maybe ExternalId
  • miiSku :: SKU
  • miiStatus :: Status
  • miiConfiguration :: Configuration
  • miiSuccess :: Success
  }
• newtype Configuration = Configuration {
  • unConfiguration :: Text
  }
• newtype Success = Success {
  • unSuccess :: Bool
  }
• data ModifyProductsRequest
• data ModifyProductsResponse = ModifyProductsResponse {
  • mprStatus :: ResponseStatus
  • mprResourceLocation :: ResponseResourceLocation
  • mprMessage :: ResponseMessage
  • mprResource :: GetProductsResponseResource
  • mprWarnings :: Maybe ResponseWarnings
  • mprErrors :: Maybe ProductError
  }
• data GetProductRequest
• data GetProductResponse = GetProductResponse {
  • gpreStatus :: ResponseStatus
  • gpreResourceLocation :: Maybe ResponseResourceLocation
  • gpreMessage :: ResponseMessage
  • gpreResource :: Maybe GetProductResponseResource
  • gpreWarnings :: Maybe ResponseWarnings
  • gpreErrors :: Maybe ResponseErrors
  }
• newtype GetProductResponseResource = GetProductResponseResource {
  • gprrProductWrapper :: ProductsWrapper
  }
• data ModifyProductRequest
• type ModifyProductResponse = ModifyProductsResponse
• data CreateOrderRequest
• type CreateOrderResponse = GetOrdersResponse
• data CreateOrder = CreateOrder {
  • coExternalId :: Maybe ExternalId
  • coOrderNo :: Maybe OrderNo
  • coProcessAfterDate :: Maybe ProcessAfterDate
  • coCommerceName :: Maybe CommerceName
  • coOptions :: Maybe CreateOrderOptions
  • coShipFrom :: Maybe OrderShipFrom
  • coShipTo :: OrderShipTo
  • coCommercialInvoice :: Maybe CommercialInvoice
  • coPackingList :: Maybe PackingList
  • coOrderItems :: OrderItems
  }
• data OrderItem = OrderItem {
  • oiCommercialInvoiceValue :: Maybe CommercialInvoiceValue
  • oiCommercialInvoiceValueCurrency :: Maybe CommercialInvoiceValueCurrency
  • oiQuantity :: Quantity
  • oiSku :: SKU
  }
• newtype CommercialInvoiceValueCurrency = CommercialInvoiceValueCurrency {
  • unCommercialInvoiceValueCurrency :: Text
  }
• newtype CommercialInvoiceValue = CommercialInvoiceValue {
  • unCommercialInvoiceValue :: Double
  }
• newtype OrderItems = OrderItems {
  • unOrderItems :: [OrderItem]
  }
• data PackingList = PackingList {
  • plMessage1 :: Maybe PackingListMessage
  • plMessage2 :: Maybe PackingListMessage
  • plMessage3 :: Maybe PackingListMessage
  • plOther :: Maybe PackingListOther
  }
• data PackingListMessage = PackingListMessage {
  • plmBody :: Maybe MessageBody
  • plmHeader :: Maybe MessageHeader
  • plmDocument :: Maybe MessageDocument
  • plmLocation :: Maybe MessageLocation
  }
• data PackingListOther = PackingListOther {
  • ploBody :: Maybe MessageBody
  • ploHeader :: Maybe MessageHeader
  • ploDocument :: Maybe MessageDocument
  • ploLocation :: Maybe MessageLocation
  }
• newtype MessageBody = MessageBody {
  • unMessageBody :: Text
  }
• newtype MessageHeader = MessageHeader {
  • unMessageHeader :: Text
  }
• newtype MessageDocument = MessageDocument {
  • unMessageDocument :: Text
  }
• newtype MessageLocation = MessageLocation {
  • unMessageLocation :: Text
  }
• data CommercialInvoice = CommercialInvoice {
  • ciAdditionalValue :: AdditionalValue
  • ciAdditionalValueCurrency :: AdditionalValueCurrency
  • ciInsuranceValue :: InsuranceValue
  • ciInsuranceValueCurrency :: InsuranceValueCurrency
  • ciShippingValue :: ShippingValue
  • ciShippingValueCurrency :: ShippingValueCurrency
  }
• newtype AdditionalValue = AdditionalValue {
  • unAdditionalValue :: Centi
  }
• newtype AdditionalValueCurrency = AdditionalValueCurrency {
  • unAdditionalValueCurrency :: Text
  }
• newtype InsuranceValue = InsuranceValue {
  • unInsuranceValue :: Centi
  }
• newtype InsuranceValueCurrency = InsuranceValueCurrency {
  • unInsuranceValueCurrency :: Text
  }
• newtype ShippingValue = ShippingValue {
  • unShippingValue :: Centi
  }
• newtype ShippingValueCurrency = ShippingValueCurrency {
  • unShippingValueCurrency :: Text
  }
• data OrderShipTo = OrderShipTo {
  • ostEmail :: Maybe Email
  • ostName :: Name
  • ostCompany :: Maybe Company
  • ostAddress1 :: AddressLine
  • ostAddress2 :: Maybe AddressLine
  • ostAddress3 :: Maybe AddressLine
  • ostCity :: City
  • ostState :: State
  • ostPostalCode :: Maybe PostalCode
  • ostCountry :: Country
  • ostPhone :: Phone
  • ostIsCommercial :: IsCommercial
  • ostIsPoBox :: Maybe IsPoBox
  }
• newtype OrderShipFrom = OrderShipFrom {
  • osfCompany :: Maybe ShipFromCompany
  }
• newtype Company = Company {
  • unCompany :: Text
  }
• newtype ShipFromCompany = ShipFromCompany {
  • unShipFromCompany :: Text
  }
• data CreateOrderOptions = CreateOrderOptions {
  • cooWarehouseId :: Maybe WarehouseId
  • cooWarehouseExternalId :: Maybe WarehouseExternalId
  • cooWarehouseRegion :: Maybe WarehouseRegion
  • cooWarehouseArea :: Maybe WarehouseArea
  • cooServiceLevelCode :: ServiceLevelCode
  • cooCarrierCode :: Maybe CarrierCode
  • cooSameDay :: SameDay
  • cooForceDuplicate :: Maybe ForceDuplicate
  • cooForceAddress :: Maybe ForceAddress
  • cooChannelName :: Maybe ChannelName
  • cooReferrer :: Maybe Referrer
  • cooAffiliate :: Maybe Affiliate
  • cooCurrency :: Currency
  • cooCanSplit :: Maybe CanSplit
  • cooNote :: Maybe Note
  • cooDiscountCode :: Maybe DiscountCode
  • cooHold :: Maybe Hold
  • cooHoldReason :: Maybe HoldReason
  • cooServer :: Maybe Server
  }
• newtype Server = Server {
  • unServer :: Text
  }
• newtype HoldReason = HoldReason {
  • unHoldReason :: Text
  }
• data Hold
  • = Hold
  • | DontHold
• newtype DiscountCode = DiscountCode {
  • unDiscountCode :: Text
  }
• newtype Affiliate = Affiliate {
  • unAffiliate :: Text
  }
• newtype Referrer = Referrer {
  • unReferrer :: Text
  }
• data ForceAddress
  • = ForceAddress
  • | DontForceAddress
• data ForceDuplicate
  • = ForceDuplicate
  • | DontForceDuplicate
• data SameDay
  • = SameDay
  • | NotSameDay
• newtype ProcessAfterDate = ProcessAfterDate {
  • unProcessAfterDate :: UTCTime
  }
• data GetOrdersRequest
• data GetOrdersResponse = GetOrdersResponse {
  • gorMessage :: ResponseMessage
  • gorResource :: GetOrdersResponseResource
  • gorStatus :: ResponseStatus
  • gorResourceLocation :: ResponseResourceLocation
  • gorWarnings :: Maybe ResponseWarnings
  • gorErrors :: Maybe ResponseErrors
  }
• data GetOrdersResponseResource = GetOrdersResponseResource {
  • gorrItems :: GetOrdersResponseResourceItems
  • gorrNext :: Maybe ResponseNext
  • gorrOffset :: ResponseOffset
  • gorrPrevious :: Maybe ResponsePrevious
  • gorrTotal :: ResponseTotal
  }
• newtype GetOrdersResponseResourceItems = GetOrdersResponseResourceItems {
  • gorriItems :: [GetOrdersResponseResourceItem]
  }
• data GetOrdersResponseResourceItemResource = GetOrdersResponseResourceItemResource {
  • gorrirExternalId :: Maybe ExternalId
  • gorrirOrderNo :: Maybe OrderNo
  • gorrirCommerceName :: Maybe CommerceName
  • gorrirProcessAfterDate :: Maybe ProcessAfterDate
  • gorrirStatus :: OrderStatus
  • gorrirLastUpdatedDate :: LastUpdatedDate
  • gorrirId :: Id
  • gorrirTransactionId :: TransactionId
  • gorrirNeedsReview :: NeedsReview
  • gorrirHolds :: GetOrdersHolds
  • gorrirItems :: GetOrdersItems
  • gorrirTrackings :: GetOrdersTrackings
  • gorrirReturns :: GetOrdersReturns
  • gorrirOptions :: GetOrdersOptions
  • gorrirShipFrom :: OrderShipFromResponse
  • gorrirShipTo :: OrderShipToResponse
  • gorrirCommercialInvoice :: CommercialInvoiceResponse
  • gorrirPackingList :: PackingListResponse
  • gorrirShippingLabel :: ShippingLabelResponse
  • gorrirRouting :: RoutingResponse
  • gorrirEvents :: EventsResponse
  • gorrirPricing :: PricingResponse
  • gorrirPricingEstimate :: PricingEstimateResponse
  • gorrirShipwireAnywhere :: ShipwireAnywhereResponse
  • gorrirSplitOrders :: SplitOrdersResponse
  • gorrirFreightSummary :: Maybe FreightSummaryResponse
  • gorrirExtendedAttributes :: Maybe ExtendedAttributesResponse
  }
• data SplitOrdersResponse = SplitOrdersResponse {
  • sorResource :: Maybe SplitOrdersResponseResource
  • sorResourceLocation :: ResponseResourceLocation
  }
• data SplitOrdersResponseResource = SplitOrdersResponseResource {
  • sorrItems :: SplitOrdersResponseResourceItems
  • sorrNext :: Maybe ResponseNext
  • sorrOffset :: ResponseOffset
  • sorrPrevious :: Maybe ResponsePrevious
  • sorrTotal :: ResponseTotal
  }
• newtype SplitOrdersResponseResourceItems = SplitOrdersResponseResourceItems {
  • sorriItems :: Array
  }
• data ShipwireAnywhereResponse = ShipwireAnywhereResponse {
  • sarResource :: ShipwireAnywhereResponseResource
  • sarResourceLocation :: Maybe ResponseResourceLocation
  }
• newtype ShipwireAnywhereResponseResource = ShipwireAnywhereResponseResource {
  • sarrStatus :: Maybe Status
  }
• data PricingEstimateResponse = PricingEstimateResponse {
  • perResource :: PricingEstimateResource
  • perResourceLocation :: Maybe ResponseResourceLocation
  }
• data PricingResponse = PricingResponse {
  • prResource :: PricingResponseResource
  • prResourceLocation :: Maybe ResponseResourceLocation
  }
• type PricingEstimateResource = PricingResponseResource
• data RoutingResponseResource = RoutingResponseResource {
  • rrrWarehouseId :: Maybe WarehouseId
  • rrrWarehouseExternalId :: Maybe WarehouseExternalId
  • rrrWarehouseName :: Maybe WarehouseName
  • rrrDestinationLatitude :: Maybe DestinationLatitudeResponse
  • rrrDestinationLongitude :: Maybe DestinationLongitudeResponse
  • rrrOriginLatitude :: OriginLatitudeResponse
  • rrrOriginLongitude :: OriginLongitudeResponse
  }
• newtype DestinationLatitudeResponse = DestinationLatitudeResponse {
  • unDestinationLatitudeResponse :: Text
  }
• newtype DestinationLongitudeResponse = DestinationLongitudeResponse {
  • unDestinationLongitudeResponse :: Text
  }
• type OriginLatitudeResponse = Latitude
• type OriginLongitudeResponse = Longitude
• data ShippingLabelResponse = ShippingLabelResponse {
  • slrResource :: Maybe ShippingLabelResponseResource
  • slrResourceLocation :: Maybe ResponseResourceLocation
  }
• data ShippingLabelResponseResource = ShippingLabelResponseResource {
  • slrrOrderId :: OrderId
  • slrrExternalid :: Maybe ExternalId
  • slrrWarehouseId :: Maybe WarehouseId
  • slrrWarehouseExternalId :: Maybe WarehouseExternalId
  • slrrDocumentLocation :: DocumentLocation
  }
• data PackingListResponse = PackingListResponse {
  • plrResource :: Maybe PackingListResponseResource
  • plrResourceLocation :: Maybe ResponseResourceLocation
  }
• data PackingListResponseResource = PackingListResponseResource {
  • plrrMessage1 :: PackingListResponseResourceMessage
  • plrrMessage2 :: PackingListResponseResourceMessage
  • plrrMessage3 :: PackingListResponseResourceMessage
  • plrrOther :: PackingListResponseResourceOther
  • plrrDocumentLocation :: DocumentLocation
  }
• data PackingListResponseResourceOther = PackingListResponseResourceOther {
  • plrroResource :: PackingListResponseResourceOtherResource
  • plrroResourceLocation :: Maybe ResponseResourceLocation
  }
• type PackingListResponseResourceOtherResource = PackingListOther
• data PackingListResponseResourceMessage = PackingListResponseResourceMessage {
  • plrrmResource :: PackingListResponseResourceMessageResource
  • plrrmResourceLocation :: Maybe ResponseResourceLocation
  }
• data CommercialInvoiceResponse = CommercialInvoiceResponse {
  • cirResource :: Maybe CommercialInvoiceResponseResource
  • cirResourceLocation :: Maybe ResponseResourceLocation
  }
• data CommercialInvoiceResponseResource = CommercialInvoiceResponseResource {
  • cirrAdditionalValue :: Maybe AdditionalValue
  • cirrInsuranceValue :: Maybe InsuranceValue
  • cirrShippingValue :: Maybe ShippingValue
  • cirrDocumentLocation :: DocumentLocation
  }
• newtype DocumentLocation = DocumentLocation {
  • unDocumentLocation :: Text
  }
• data OrderShipToResponse = OrderShipToResponse {
  • gostResource :: OrderShipToResponseResource
  • gostResourceLocation :: Maybe ResponseResourceLocation
  }
• type OrderShipToResponseResource = OrderShipTo
• data OrderShipFromResponse = OrderShipFromResponse {
  • gosfResource :: OrderShipFromResponseResource
  • gosfResourceLocation :: Maybe ResponseResourceLocation
  }
• data OrderShipFromResponseResource = OrderShipFromResponseResource {
  • osfrrCompany :: Maybe ShipFromCompany
  }
• data GetOrdersOptions = GetOrdersOptions {
  • gooResource :: GetOrdersOptionsResource
  • gooResourceLocation :: Maybe ResponseResourceLocation
  }
• data GetOrdersOptionsResource = GetOrdersOptionsResource {
  • goorWarehouseId :: Maybe WarehouseId
  • goorWarehouseExternalId :: Maybe WarehouseExternalId
  • goorWarehouseRegion :: Maybe WarehouseRegion
  • goorWarehouseArea :: Maybe WarehouseArea
  • goorServiceLevelCode :: Maybe ServiceLevelCode
  • goorCarrierCode :: Maybe CarrierCode
  • goorSameDay :: SameDay
  • goorForceDuplicate :: ForceDuplicate
  • goorForceAddress :: ForceAddress
  • goorChannelName :: Maybe ChannelName
  • goorReferrer :: Referrer
  }
• data GetOrdersReturns = GetOrdersReturns {
  • gordResource :: Maybe GetOrdersReturnsResource
  • gordResourceLocation :: ResponseResourceLocation
  }
• data GetOrdersReturnsResource = GetOrdersReturnsResource {
  • gordrItems :: GetOrdersReturnsResourceItems
  • gordrNext :: Maybe ResponseNext
  • gordrOffset :: ResponseOffset
  • gordrPrevious :: Maybe ResponsePrevious
  • gordrTotal :: ResponseTotal
  }
• newtype GetOrdersReturnsResourceItems = GetOrdersReturnsResourceItems {
  • gordri :: Array
  }
• data GetOrdersTrackings = GetOrdersTrackings {
  • gotResource :: Maybe GetOrdersTrackingsResource
  • gotResourceLocation :: ResponseResourceLocation
  }
• data GetOrdersTrackingsResource = GetOrdersTrackingsResource {
  • gotrItems :: GetOrdersTrackingsResourceItems
  • gotrNext :: Maybe ResponseNext
  • gotrOffset :: ResponseOffset
  • gotrPrevious :: Maybe ResponsePrevious
  • gotrTotal :: ResponseTotal
  }
• newtype GetOrdersTrackingsResourceItems = GetOrdersTrackingsResourceItems {
  • gotriItems :: [GetOrdersTrackingsResourceItem]
  }
• data GetOrdersTrackingsResourceItem = GetOrdersTrackingsResourceItem {
  • gotriResource :: GetOrdersTrackingsResourceItemResource
  • gotriResourceLocation :: ResponseResourceLocation
  }
• data GetOrdersTrackingsResourceItemResource = GetOrdersTrackingsResourceItemResource {
  • gotrirId :: Id
  • gotrirOrderid :: OrderId
  • gotrirOrderExternalid :: Maybe OrderExternalId
  • gotrirTracking :: Tracking
  • gotrirCarrier :: CarrierName
  • gotrirUrl :: Maybe URL
  • gotrirSummary :: Maybe Summary
  • gotrirSummaryDate :: Maybe SummaryDate
  • gotrirLabelCreatedDate :: Maybe LabelCreatedDate
  • gotrirTrackedDate :: Maybe TrackedDate
  • gotrirFirstScanDate :: Maybe FirstScanDate
  • gotrirFirstScanRegion :: Maybe FirstScanRegion
  • gotrirFirstScanPostalCode :: Maybe FirstScanPostalCode
  • gotrirFirstScanCountry :: Maybe FirstScanCountry
  • gotrirDeliveredDate :: Maybe DeliveredDate
  • gotrirDeliveryCity :: Maybe DeliveryCity
  • gotrirDeliveryRegion :: Maybe DeliveryRegion
  • gotrirDeliveryPostalCode :: Maybe DeliveryPostalCode
  • gotrirDeliveryCountry :: Maybe DeliveryCountry
  }
• type FirstScanRegion = Region
• type FirstScanPostalCode = PostalCode
• type FirstScanCountry = Country
• type DeliveryCity = City
• type DeliveryRegion = Region
• type DeliveryPostalCode = PostalCode
• type DeliveryCountry = Country
• newtype FirstScanDate = FirstScanDate {
  • unFirstScanDate :: UTCTime
  }
• newtype LabelCreatedDate = LabelCreatedDate {
  • unLabelCreatedDate :: UTCTime
  }
• data GetOrdersItems = GetOrdersItems {
  • goiResource :: Maybe GetOrdersItemsResource
  • goiResourceLocation :: ResponseResourceLocation
  }
• data GetOrdersItemsResource = GetOrdersItemsResource {
  • goirItems :: GetOrdersItemsResourceItems
  • goirNext :: Maybe ResponseNext
  • goirOffset :: ResponseOffset
  • goirPrevious :: Maybe ResponsePrevious
  • goirTotal :: ResponseTotal
  }
• newtype GetOrdersItemsResourceItems = GetOrdersItemsResourceItems {
  • goiriItems :: [GetOrdersItemsResourceItem]
  }
• data GetOrdersItemsResourceItem = GetOrdersItemsResourceItem {
  • goiriResource :: GetOrdersItemsResourceItemResource
  • goiriResourceLocation :: Maybe ResponseResourceLocation
  }
• data GetOrdersItemsResourceItemResource = GetOrdersItemsResourceItemResource {
  • goirirProductId :: ProductId
  • goirirProductExternalId :: Maybe ProductExternalId
  • goirirSku :: SKU
  • goirirOrderId :: OrderId
  • goirirOrderExternalId :: Maybe OrderExternalId
  • goirirQuantity :: Quantity
  • goirirCommercialInvoiceValue :: Maybe CommercialInvoiceValue
  • goirirSerialNumbers :: SerialNumbersResponse
  • goirirOrdered :: Ordered
  • goirirBackordered :: Maybe Backordered
  • goirirReserved :: Reserved
  • goirirShipping :: Shipping
  • goirirShipped :: Shipped
  }
• newtype Shipped = Shipped {
  • unShipped :: Integer
  }
• newtype Shipping = Shipping {
  • unShipping :: Integer
  }
• newtype Reserved = Reserved {
  • unResered :: Integer
  }
• newtype Backordered = Backordered {
  • unBackordered :: Integer
  }
• newtype Ordered = Ordered {
  • unOrdered :: Integer
  }
• data SerialNumbersResponse = SerialNumbersResponse {
  • snrResource :: SerialNumbersResponseResource
  • snrResourceLocation :: ResponseResourceLocation
  }
• data SerialNumbersResponseResource = SerialNumbersResponseResource {
  • snrrItems :: SerialNumbersResponseResourceItems
  • snrrNext :: Maybe Next
  • snrrOffset :: ResponseOffset
  • snrrPrevious :: Maybe ResponsePrevious
  • snrrTotal :: ResponseTotal
  }
• newtype SerialNumbersResponseResourceItems = SerialNumbersResponseResourceItems {
  • snrriItems :: [SerialNumbersResponseResourceItem]
  }
• data SerialNumbersResponseResourceItem = SerialNumbersResponseResourceItem {
  • snrriResource :: SerialNumbersResponseResourceItemResource
  • snrriResourceLocation :: Maybe ResponseResourceLocation
  }
• data SerialNumbersResponseResourceItemResource = SerialNumbersResponseResourceItemResource {
  • snrrirOrderId :: OrderId
  • snrrirProductId :: ProductId
  • snrrirSerialNumber :: Maybe SerialNumber
  }
• newtype SerialNumber = SerialNumber {
  • unSerialNumber :: Text
  }
• data GetOrdersHolds = GetOrdersHolds {
  • gohResource :: Maybe GetOrdersHoldsResource
  • gohResourceLocation :: ResponseResourceLocation
  }
• data GetOrdersHoldsResource = GetOrdersHoldsResource {
  • gohrItems :: GetOrdersHoldsResourceItems
  • gohrNext :: Maybe ResponseNext
  • gohrOffset :: ResponseOffset
  • gohrPrevious :: Maybe ResponsePrevious
  • gohrTotal :: ResponseTotal
  }
• newtype GetOrdersHoldsResourceItems = GetOrdersHoldsResourceItems {
  • gohriItems :: [GetOrdersHoldsResourceItem]
  }
• data GetOrdersHoldsResourceItem = GetOrdersHoldsResourceItem {
  • gohriResource :: GetOrdersHoldsResourceItemResource
  • gohriResourceLocation :: Maybe ResponseResourceLocation
  }
• data GetOrdersHoldsResourceItemResource = GetOrdersHoldsResourceItemResource {
  • gohrirId :: Id
  • gohrirOrderId :: OrderId
  • gohrirExternalOrderId :: Maybe ExternalOrderId
  • gohrirType :: Maybe Type
  • gohrirDescription :: Description
  • gohrirAppliedDate :: AppliedDate
  • gohrirClearedDate :: Maybe ClearedDate
  }
• newtype NeedsReview = NeedsReview {
  • unNeedsReview :: Integer
  }
• type EventsResponse = ItemResourceEvents
• data GetOrdersResponseResourceItem = GetOrdersResponseResourceItem {
  • gorriResource :: GetOrdersResponseResourceItemResource
  • gorriResourceLocation :: ResponseResourceLocation
  }
• data PricingResponseResource = PricingResponseResource {
  • prrShipping :: ShippingValue
  • prrPackaging :: PackagingValue
  • prrInsurance :: InsuranceValue
  • prrHandling :: HandlingValue
  • prrTotal :: TotalValue
  }
• newtype TotalValue = TotalValue {
  • unTotalValue :: Centi
  }
• newtype HandlingValue = HandlingValue {
  • unHandlingValue :: Centi
  }
• newtype PackagingValue = PackagingValue {
  • unPackagingValue :: Centi
  }
• data RoutingResponse = RoutingResponse {
  • rrResource :: RoutingResponseResource
  • rrResourceLocation :: Maybe ResponseResourceLocation
  }
• data ExpandOrders
  • = OrdersExpandAll
  • | OrdersExpandHolds
  • | OrdersExpandItems
  • | OrdersExpandReturns
  • | OrdersExpandTrackings
  • | OrdersExpandSplitOrders
• newtype ExpandOrdersParam = ExpandOrdersParam {
  • unExpandOrdersParam :: [ExpandOrders]
  }
• expandOrdersToBS8 :: ExpandOrders -> ByteString
• newtype OrderStatusParam = OrderStatusParam {
  • unStatusParam :: [OrderStatus]
  }
• data OrderStatus
  • = OrderProcessed
  • | OrderCanceled
  • | OrderCompleted
  • | OrderDelivered
  • | OrderReturned
  • | OrderSubmitted
  • | OrderHeld
  • | OrderTracked
• newtype ReferrerParam = ReferrerParam {
  • unReferrerParam :: [Text]
  }
• data CancelOrderRequest
• type CancelOrderResponse = SimpleResponse
• data IdWrapper
  • = WrappedId Id
  • | WrappedExternalId ExternalId
• data GetOrderTrackingsRequest
• data GetOrderTrackingsResponse = GetOrderTrackingsResponse {
  • gotrMessage :: ResponseMessage
  • gotrResource :: GetOrderTrackingsResponseResource
  • gotrResourceLocation :: ResponseResourceLocation
  • gotrStatus :: ResponseStatus
  • gotrWarnings :: Maybe ResponseWarnings
  • gotrErrors :: Maybe ResponseErrors
  }
• data GetOrderTrackingsResponseResource = GetOrderTrackingsResponseResource {
  • gotrrItems :: GetOrderTrackingsResponseResourceItems
  • gotrrNext :: Maybe ResponseNext
  • gotrrOffset :: ResponseOffset
  • gotrrPrevious :: Maybe ResponsePrevious
  • gotrrTotal :: ResponseTotal
  }
• newtype GetOrderTrackingsResponseResourceItems = GetOrderTrackingsResponseResourceItems {
  • gotrriItems :: [GetOrderTrackingsResponseResourceItem]
  }
• data GetOrderTrackingsResponseResourceItem = GetOrderTrackingsResponseResourceItem {
  • gotrriResource :: GetOrderTrackingsResponseResourceItemResource
  • gotrriResourceLocation :: ResponseResourceLocation
  }
• data GetOrderTrackingsResponseResourceItemResource = GetOrderTrackingsResponseResourceItemResource {
  • gotrrirId :: Id
  • gotrrirOrderId :: OrderId
  • gottrirOrderExternalId :: OrderExternalId
  • gotrrirTracking :: Tracking
  • gotrrirCarrier :: CarrierName
  • gotrrirUrl :: URL
  • gotrrirSummary :: Summary
  • gotrrirSummaryDate :: SummaryDate
  • gotrrirLabelCreatedDate :: LabelCreatedDate
  • gotrrirTrackedDate :: TrackedDate
  • gotrrirFirstScanDate :: FirstScanDate
  • gotrrirFirstScanRegion :: FirstScanRegion
  • gotrrirFirstScanPostalCode :: FirstScanPostalCode
  • gotrrirFirstScanCountry :: FirstScanCountry
  • gotrrirDeliveredDate :: DeliveredDate
  • gotrrirDeliveryCity :: DeliveryCity
  • gotrrirDeliveryRegion :: DeliveryRegion
  • gotrrirDeliveryPostalCode :: DeliveryPostalCode
  • gotrrirDeliveryCountry :: DeliveryCountry
  }
• data ValidateAddressRequest
• data ValidateAddressResponse = ValidateAddressResponse {
  • varStatus :: ResponseStatus
  • varMessage :: ResponseMessage
  • varResource :: ValidateAddressResponseResource
  • varResourceLocation :: Maybe ResponseResourceLocation
  • varWarnings :: Maybe ValidateAddressWarnings
  • varErrors :: Maybe Object
  }
• type ValidateAddressResponseResource = OrderShipTo
• type AddressToValidate = OrderShipTo
• newtype ValidateAddressWarnings = ValidateAddressWarnings {
  • vawWarningObject :: WarningObject
  }
• data WarningObject = WarningObject {
  • woEmail :: Maybe InnerWarningObject
  • woName :: Maybe InnerWarningObject
  • woCompany :: Maybe InnerWarningObject
  • woAddress1 :: Maybe InnerWarningObject
  • woAddress2 :: Maybe InnerWarningObject
  • woAddress3 :: Maybe InnerWarningObject
  • woCity :: Maybe InnerWarningObject
  • woState :: Maybe InnerWarningObject
  • woPostalCode :: Maybe InnerWarningObject
  • woCountry :: Maybe InnerWarningObject
  • woPhone :: Maybe InnerWarningObject
  • woIsCommercial :: Maybe InnerWarningObject
  • woIsPoBox :: Maybe InnerWarningObject
  }
• data GetOrderRequest
• data GetOrderResponse = GetOrderResponse {
  • goreMessage :: ResponseMessage
  • goreResource :: GetOrderResponseResource
  • goreStatus :: ResponseStatus
  • goreResourceLocation :: ResponseResourceLocation
  • goreWarnings :: Maybe ResponseWarnings
  • goreErrors :: Maybe ResponseErrors
  }
• type GetOrderResponseResource = GetOrdersResponseResourceItemResource
• data ExtendedAttributesResponse = ExtendedAttributesResponse {
  • earResource :: Maybe ExtendedAttributesResponseResource
  • earResourceLocation :: Maybe ResponseResourceLocation
  }
• data ExtendedAttributesResponseResource = ExtendedAttributesResponseResource {
  • earrOffset :: Offset
  • earrTotal :: Total
  • earrPrevious :: Maybe Previous
  • earrNext :: Maybe Next
  • earrItems :: ExtendedAttributesResponseResourceItems
  }
• newtype ExtendedAttributesResponseResourceItems = ExtendedAttributesResponseResourceItems {
  • earriItems :: [ExtendedAttributesResponseResourceItem]
  }
• data ExtendedAttributesResponseResourceItem = ExtendedAttributesResponseResourceItem {
  • earriResource :: ExtendedAttributesResponseResourceItemResource
  • earriResourceLocation :: Maybe ResponseResourceLocation
  }
• data ExtendedAttributesResponseResourceItemResource = ExtendedAttributesResponseResourceItemResource {
  • earrirName :: Name
  • earrirValue :: ExtendedAttributeValue
  • earrirType :: Type
  }
• newtype ExtendedAttributeValue = ExtendedAttributeValue {
  • unExtendedAtttributeValue :: Double
  }
• data FreightSummaryResponse = FreightSummaryResponse {
  • fsrResource :: FreightSummaryResponseResource
  • fsrResourceLocation :: Maybe ResponseResourceLocation
  }
• data FreightSummaryResponseResource = FreightSummaryResponseResource {
  • fsrrTotalWeight :: FreightSummaryTotalWeight
  • fsrrWeightUnit :: Maybe WeightUnit
  • fsrrMeasurementType :: Maybe MeasurementType
  }
• newtype MeasurementType = MeasurementType {
  • unMeasurementType :: Text
  }
• newtype FreightSummaryTotalWeight = FreightSummaryTotalWeight {
  • unFreightSummaryTotalWeight :: Text
  }
• data ErrorObject = ErrorObject {
  • eoEmail :: Maybe InnerErrorObject
  • eoName :: Maybe InnerErrorObject
  • eoCompany :: Maybe InnerErrorObject
  • eoAddress1 :: Maybe InnerErrorObject
  • eoAddress2 :: Maybe InnerErrorObject
  • eoAddress3 :: Maybe InnerErrorObject
  • eoCity :: Maybe InnerErrorObject
  • eoState :: Maybe InnerErrorObject
  • eoPostalCode :: Maybe InnerErrorObject
  • eoCountry :: Maybe InnerErrorObject
  • eoPhone :: Maybe InnerErrorObject
  • eoIsCommercial :: Maybe InnerErrorObject
  • eoIsPoBox :: Maybe InnerErrorObject
  }
• newtype ValidateAddressErrors = ValidateAddressErrors {
  • vaeErrorObject :: ErrorObject
  }
• newtype InnerErrorObject = InnerErrorObject {
  • ieoRules :: InnerErrorObjectRules
  }
• newtype InnerErrorObjectRules = InnerErrorObjectRules {
  • ieorObject :: Object
  }
• newtype InnerWarningObject = InnerWarningObject {
  • iwoRules :: InnerWarningObjectRules
  }
• newtype InnerWarningObjectRules = InnerWarningObjectRules {
  • iworObject :: Object
  }