swagger: '2.0' info: version: 1.7.0 title: paccurate.io paths: /: post: description: | a pure-JSON endpoint for packing requests. produces: - application/json consumes: - application/json parameters: - name: pack in: body description: complete set of items, boxes, and parameters to pack. schema: $ref: "#/definitions/Pack" responses: 200: description: Successful pack. schema: type: object title: PackResponse properties: boxes: description: List of boxes, packed, with their contained items. type: array items: type: object properties: box: $ref: '#/definitions/Box' title: description: title of packing result, when applicable. type: string built: description: build timestamp of engine. type: string startedAt: description: start timestamp of pack. type: string version: description: version of engine type: string lenBoxes: description: cardinality of all packed boxes type: integer lenItems: description: total sum of quantities of all items type: integer lenUnits: description: cardinality of distinct units of items (count of cases, eaches, etc.) type: integer lenLeftovers: description: cardinality of items unabled to be packed type: integer totalCost: description: total estimated cost of all packed boxes, when applicable, in cents. type: integer totalVolume: description: total volume of all boxes returned type: number totalVolumeNet: description: total net (item) volume of all packed (non-leftover) items type: number totalVolumeUsed: description: total net volume plus reserved volume from "reservedSpace" type: number totalVolumeUtilization: description: totalVolumeUsed divided by totalVolume type: number totalWeight: description: total gross weight of all packed boxes, including box tare weights and item weights. type: number packTime: description: seconds spent in packing type: number renderTime: description: seconds spent in rendering and placement instruction creation of packing solution type: number totalTime: description: seconds spent generating response, total. type: number leftovers: description: items left over that could not be packed into any available boxes. type: array items: $ref: '#/definitions/Item' itemSortUsed: description: name of item sort algorithm used. type: string itemSortReverseUsed: description: whether the item sort was reversed. type: boolean boxTypeChoiceGoalUsed: description: name of box type choice goal used. type: string scripts: description: additional javascripts for any image loading. type: string styles: description: additional styles for pack images type: string svgs: description: all box SVG images type: array items: type: string orderId: description: a client-provided string identifier for the order this pack corresponds to. type: string requestId: description: a client-provided string identifier for the pack request being made. type: string images: description: if PNG imageFormat selected, list of PNG image objects. type: array items: $ref: '#/definitions/Image' usedKeyStem: description: stem of authorization key used, if any. type: string warnings: description: any warning messages about non-critical issues arising during the pack. required: false type: array items: type: string requestFingerprint: description: a fingerprint corresponding to the request content for identification within Paccurate Manager. type: string responseFingerprint: description: a fingerprint corresponding to the response content for identification within Paccurate Manager type: string packUuid: description: a unique identifier for this pack transaction, which can be used to directly retrieve the pack via the Paccurate Manager. type: string 400: description: Bad request. Malformed or some other problem occurred processing the request. schema: $ref: "#/definitions/Error" 422: description: Invalid input. The request was well-formed, but the parameters were contradictory, invalid, or otherwise somehow unable to be processed. More information will be contained in the error details. schema: $ref: "#/definitions/Error" 429: description: Rate limited. Without an API key, only 10 unique requests are allowed per day for testing or demonstration purposes. Note that a randomized pack repeated is only a single unique request. schema: $ref: "#/definitions/Error" 500: description: Unexpected error. schema: $ref: "#/definitions/Error" definitions: Error: type: object required: - message - code properties: message: type: string details: type: string code: type: integer minimum: 100 maximum: 600 Pack: type: object properties: key: description: issued API key. type: string requestId: description: a client-provided string identifier for the pack request being made. type: string orderId: description: a client-provided string identifier for the order this pack corresponds to. type: string layFlat: description: aligns all items laying flat. If possible, it may create a "brick-laying" pattern to increase stability. type: boolean default: false interlock: description: alternates layFlat orientation by layer, so as to create an interlocked placement pattern and improve item stability. type: boolean default: false corners: type: boolean description: only pack items at valid corner points of other items (optimal) default: true itemSets: description: item set definitions if not creating random items. type: array items: $ref: "#/definitions/ItemSet" example: - refId: 0 color: tomato dimensions: x: 4.2 y: 7 z: 8 weight: 4.5 quantity: 10 - refId: 1 color: cornflowerblue dimensions: x: 3 y: 3 z: 5 weight: 2 quantity: 13 boxTypes: description: box type definitions for packing, will override boxTypeSets defined. type: array items: $ref: "#/definitions/BoxType" boxTypeGenerators: description: list of dynamic boxTypeGenerators to use, in combination with boxTypes type: array items: $ref: "#/definitions/BoxTypeGenerator" boxTypeDefaults: description: default attributes for all "boxTypes", to be overridden by any individual "boxType" attributes specified. example: weightMax: 50 rateTable: dimFactor: 166 allOf: - $ref: "#/definitions/BoxProperties" boxes: description: pre-packed boxes, including any items specified that will be packed and excess space used before any new boxes are created. type: array items: $ref: "#/definitions/Box" example: [] usableSpace: description: an estimate of typical box utilization for the quick "estimated" boxTypeChoiceStyle, which will be used to ensure "estimated" box type choices are not overly optimistic regarding potential volume utilization. minimum: 0 maximum: 1 default: 0.85 example: 0.85 type: number reservedSpace: description: space in boxes that is reserved, i.e., for packing material. minimum: 0 maximum: 1 default: 0 example: 0.2 type: number boxTypeSets: description: predefined box types to be used, separated by commas. Will be overridden by boxTypes. Acceptable values are
When selecting the next available boxType, we must consider how far to look ahead.
Consider we have 8 items of identical dimensions, and two flat rate boxTypes. It is found that Box A can fit 6 items, and costs $12. Box B can fit 4 items, and costs $10.
If we consider only the next box, i.e., 'boxTypeChoiceLookahead' set to 0, we would select Box A. It costs $2 per item, whereas Box B is $2.50 per item. Box A is opened, 6 items are placed inside, and now 2 remain. To pack the last 2, Box B would be selected, as 2 items for $10 is $5 per item, and Box A's $12 is $6 per item.
Alternatively, if 'boxTypeChoiceLookahead' is set to 1, the boxType that provides the lowest cost per item including the lookahead boxType(s) would be selected. In this case, we find we need 2 of Box B, for $20 total, to fit all 8 items, or $2.50 per item, and would need 1 of Box A and 1 of Box B if Box A is selected first, for $22 total or $2.75 per item. Box B would be used.
Please note that 'boxTypeChoiceLookahead', especially when combined with the 'actual' 'boxTypeChoiceStyle' can have significant performance impacts. 0 is recommended for real-time use cases.
type: integer default: 0 boxTypeChoiceLookback: description: Control the ability for partially-filled boxes to allow packing of later-sorted items. A value of null or -1 means unlimited lookback is permitted, i.e., every box can be used to pack any allowable item that fits regardless of its pack sequence, and all boxes will remain "opened" or available for packing until the last item in the pack sequence is attempted. A value of 0 means lookback is not allowed, and as soon as the next item in the pack sequence does not fit into a partially filled box, that box is "closed" or locked and will not permit any additional items (i.e., out-of-sequence items) to be packed in it. type: integer default: -1 boxTypeChoiceGoal: description: The objective to evaluate boxTypeChoices by. 'lowest-cost' minimizes price or volume cost of boxTypes selected, 'most-items' maximizes item count per box opened, i.e., fewest total boxes used. type: string default: lowest-cost enum: - lowest-cost - most-items boxesMax: description: The maximum number of boxes to be used to pack the items in the request, potentially leaving items in 'leftovers' if there is insufficient space, determined by item 'sequence' or selected 'itemSort'. If existing 'boxes' are passed to the pack request, they count towards this total, but will not be excluded, allowing for situations where 'lenBoxes' may be greater than 'boxesMax'. However, no 'boxTypes' will be used to create additional boxes unless doing so would not exceed 'boxesMax'. type: integer default: 0 boxesPerItemSetMax: description: The maximum number of boxes that a single ItemSet's member items (i.e., all that share the same refId) can be spread across. Any items that do not fit within this number of boxes will be precluded from packing and returned in the leftovers array. The default setting of 0, a negative number, and null are all equivalent and indicate no maximum limit. type: integer default: 0 boxesPerSequenceMax: description: The maximum number of boxes that a single non-empty sequence's member items (i.e., all that share the same non-empty sequence) can be spread across. Any items that do not fit within this number of boxes will be precluded from packing and returned in the leftovers array. The default setting of 0, a negative number, and null are all equivalent and indicate no maximum limit. type: integer default: 0 itemsPerBoxMax: description: The maximum quantity of discrete items that a single box can contain. The default setting of 0, a negative number, and null are all equivalent and indicate no maximum limit, optionally overridden by 'boxType' settings. type: integer default: 0 itemSetsPerBoxMax: description: The maximum quantity of unique 'item.refId' values that a single box can contain. The default setting of 0, a negative number, and null are all equivalent and indicate no maximum limit, optionally overridden by 'boxType' settings. type: integer default: 0 itemsInlineMax: description: Limit the item count that can share a placement on a specific line parallel to the placement axis, e.g., '[1,2,1]' means items can be placed 1 high, 2 wide, and 1 deep within the box. A value of '0' is equivalent to no limit along that axis. Overridden by 'boxType' settings. type: array items: type: integer maxLength: 3 minLength: 3 example: [1,2,1] generatedBoxTypesMax: description: The maximum number of generated box sizes to randomly sampled when generating box types. Default of 0 is unlimited, and in some cases may never return without a limit. `64` is a sensible value. type: integer default: 0 example: 64 valueTiebreaker: description: The tiebreaker to use in the event to box type choices are otherwise completely equal. Default is "volume", alternative is "weight". type: string default: volume enum: - volume - weight timeout: description: Optional timeout for request computation, will be reduced to endpoint maximum if in excess of published timeout. type: number example: 30 BoxProperties: type: object properties: name: type: string description: name for the type of box. refId: type: integer description: box type reference identifier passed backed from request. price: type: integer description: Fixed price of the container, in whole units of currency, default USD cents. This can represent the cost of a flat rate carton, the cost of the actual carton materials, or it can include any other flat fees that may need to be added on a per-carton basis, such as handling, accessorial surchages, oversize fees, etc. This value is added to any rate table rates defined for the carton. minimum: 0 weightTare: type: number description: weight of the container when empty or otherwise unladen, i.e., of the box itself. minimum: 0 default: 0 weightMax: type: number description: maximum allowable gross weight for the box, i.e., all packed item weights plus the weightTare. minimum: 0 dimensions: description: the [height,length,width] of the box. allOf: - $ref: "#/definitions/Point" centerOfMass: description: the coordinates of the center of mass of the box. allOf: - $ref: "#/definitions/Point" reservedSpace: description: space in boxes that is reserved, i.e., for packing material, overriding top-level 'reservedSpace'. minimum: 0 maximum: 1 default: 0 example: 0.2 type: number itemsPerBoxMax: description: The maximum quantity of discrete items that a single box can contain. The default setting of 0, a negative number, and null are all equivalent and indicate no maximum limit, overriding top-level 'itemsPerBoxMax'. type: integer default: 0 itemSetsPerBoxMax: description: The maximum quantity of unique 'item.refId' values that a single box can contain. The default setting of 0, a negative number, and null are all equivalent and indicate no maximum limit, overriding top-level 'itemSetsPerBoxMax' settings. type: integer default: 0 itemsInlineMax: description: Limit the item count that can share a placement on a specific line parallel to the placement axis, e.g., '[1,2,1]' means items can be placed 1 high, 2 wide, and 1 deep within the box. A value of '0' is equivalent to no limit along that axis. type: array items: type: integer maxLength: 3 minLength: 3 example: [1,2,1] rateTable: description: An optional rate table definition for improved carton selection and pricing optimization. Defaults are included using retail rates for FedEx and UPS if carrier and service is provided, but optimization can be improved with more data passed in a carton's specific rate table. Methods aresorted list of 'item.index' values representing the ordering utilized by the render, back to front.
This list works in tandem with the 'eye' point, and can represent a potentially feasible real-world packing order.
E.g., if the 'eye' is set to '{x:1, y:0, z:0}', then the packing image will show a top-down view of the carton, and 'depthOrder' will contain the order to place items so that all items on the bottom of the carton are packed first, then those in the next layer, etc., so that no item is placed beneath another already placed item.
Conversely, if the 'eye' is set to '{x:0, y:0, z:1}', the packing image will show an end-on view--as if from the doors of a shipping trailer, and 'depthOrder' will contain the order to place items so that all items farthest from the doors are placed before items directly in front of them.
items: type: integer depthOrderString: type: string description: string representation of depth ordering. ItemProperties: type: object description: "general properties of an item" properties: refId: type: integer description: item type reference identifier passed backed from request, where a value of -1 or null will be auto-assigned to a unique identifier by distinct item or itemSet. name: type: string description: name or description of item for your reference. color: type: string description: designated color name or hex code (including leading "#") for the item in pack visualizations. If 'imageFormat' is set to 'PNG', the color must be a 3-byte (i.e., 6-character) case insensitive hex code plus the leading "#", e.g., "#00ffff". weight: type: number description: weight of this single packed item. sequence: type: string description: A sequence value for the item. This is intended for aisle-bin locations, e.g., aisle 11 bin 20 can be '1120'. Combined with maxSequenceDistance, you can restrict cartons to only have contents from within a certain range. This is very helpful for cartonization when picking efficiency is paramount. Sequence can also be used to pre-sort items for efficient packing on any arbitrary number, such as item weight instead of the default item volume. dimensions: description: the length, width, and height of the item. allOf: - $ref: "#/definitions/Point" centerOfMass: description: the coordinates of the center of mass of the item. allOf: - $ref: "#/definitions/Point" virtual: type: boolean default: false description: whether or not this is a real item or a virtual, blocking space (from a subspace or loading rules) required: - weight - dimensions Item: description: a specific, packed item. allOf: - $ref: "#/definitions/ItemProperties" - type: object properties: index: type: integer description: the sequence at which the item was packed. message: type: string description: any relevant information or warnings about the packing of the item. origin: description: the [x,y,z] placement point of the back-bottom corner of the item. allOf: - $ref: "#/definitions/Point" deltaCost: type: integer description: the change in the estimated final cost of the box caused by adding the item. uniqueId: type: string description: a combination of the item's refId and its packing sequence, uniquely identifying it. groupPackParent: type: string required: false description: if specified, the uniqueId of the group-pack parent item this item belongs to. quantity: type: integer description: quantity of basis item, i.e., eaches, this item represents, if dimensionSets were used with variable quantity contents. default: 1 unitOfMeasure: type: string description: unit of measure, if specified. not defined or null if none. dimensionSet: description: the "dimensionSet" used for this specific item object. allOf: - $ref: "#/definitions/DimensionSet" ItemSet: description: set of items sharing a common type. required: - quantity allOf: - $ref: "#/definitions/ItemProperties" - type: object properties: quantity: type: integer description: "quantity of items of this type in this item set" dimensionSets: type: array description: Alternate list of dimensions for automatic conversion of items into larger units of measure (optional). The first element is assumed to be "each", and will use the base "dimensions" and "weight" if none is provided. Additional units of measure are preferentially selected in reverse, from the last dimensionSet to the first. If the "quantityDivisor" value is less than the quantity of the itemSet, then the weight and dimensions are either automatically multiplied (with "axisMultipliers") or explicitly set with "dimensions" and "weight". The remaining item "quantity" is reduced by "quantityDivisor" as many times as possible, with remainders being filled by subordinate units of measure, with eaches being preserved last. Units are counted towards "lenUnits", whereas total item quantity counts towards "lenItems". NB, "alternate-dimensions" and "group-pack" should not be used with "dimensionSets" as they may cause unexpected results. items: $ref: "#/definitions/DimensionSet" DimensionSet: description: A set of dimensions for a specific item unit of measure, to be assembled in an ordered, hierarchical list of DimensionSets, each representing a whole quantity of the item. Use "dimensions", "weight", and "quantityDivisor" properties when measurements are known (e.g., 8-count case outer "dimensions" with "weight" including the empty case weight, with 8 as the "quantityDivisor"), or "axisMultipliers" when trying to pack in known multiples of the base item dimensions (or when it is unknown), e.g., a 6-pack of soda would be `"axisMultipliers":{"x":1,"y":2,"z":3}` for a 1-high by 2-wide by 3-long arrangement. All dimension sets will be used if sufficient quantities exist without regard for available container size or rules, e.g., do not pass "pallet" for a small parcel shipment. title: DimensionSet type: object properties: dimensions: description: Dimensions of the item in this configuration required: false allOf: - $ref: "#/definitions/Point" axisMultipliers: description: Multiples in x, y, and z directions of the item in this configuration. E.g., x:1, y:2, z:3 for a 3x2 6 pack of soda. If unspecified, "quantityDivisor" will default to the product of all 3 multiples. It it always relative to the basis dimensions of the item, i.e., each dimensions. required: false allOf: - $ref: "#/definitions/Point" quantityDivisor: description: The quantity of the item contained in this configuration, i.e., in pieces or eaches. type: integer required: false weight: description: The weight of the item in this configuration. If unspecified, "weight" will default to the basis item weight times "quantityDivisor". type: number required: false unitOfMeasure: description: A string used to name or label the unit of measure. The first DimensionSet will always default to "each" unless otherwise specified. type: string required: false ItemMatch: type: object description: Specify the items a rule applies to based upon a search substring of an itemSet property. Either 'all' must be set to true or both 'expression' and 'property' must be set. title: ItemMatch properties: all: description: if true, match this rule on all item sets specified in the request. type: boolean property: description: the itemSet property to search with the expression. type: string enum: - sequence - name expression: description: the query string to search the specified itemSet property for. type: string expressions: description: query strings to search the specified itemSet property for. type: array items: type: string negate: description: if true, negate substring search so rule applies only to itemSet properties not matching expression. type: boolean default: false Rule: description: "Rule definition for packing constraints." type: object properties: itemRefId: type: integer description: reference ID for the item the rule applies to. itemSequence: type: string description: sequence string shared by all items for the rule to apply to. itemMatch: description: optional object defining a substring search and property to search for items the rule applies to allOf: - $ref: "#/definitions/ItemMatch" targetItemRefIds: description: target item reference IDs that the rule applies to. type: array items: type: integer targetItemSequences: description: target item sequences that the rule applies to. type: array items: type: string targetBoxRefIds: description: target box reference IDs that the rule applies to. type: array items: type: integer operation: type: string enum: - exclude - exclude-all - pack-as-is - irregular - lock-orientation - internal-space - alternate-dimensions - fragile # - compact-pattern description: | Rule type for this definition. Valid operation values includeitemRefId contains some internal packable subspace that can be used to place subsequent items defined by a virtual boxType with an origin defined relative to the item's dimensions and with an allowable weightMax.
The internal subspace is subject to all rules and parameters of the parent box of the item.
Subspaces may nest, as in a pencil can be placed into a flower pot which may then be put inside a bucket which may then be put inside a single box.
Internal space subspaces are "opened" only when an item with an internal space is placed into a box. They are then treated preferentially over opening a new box from the specified boxTypes until their weight or volume is exhausted, or no valid placements can be found within them for remaining items.
"options" contents:
key | value | description |
---|---|---|
type | string | identifies this internal space as being defined by a subspace. |
boxType | BoxType | BoxType definition, values specified are used except price and rate and unless superseded by parent BoxType attributes. |
origin | Point | origin of the subspace relative to Item dimensions. |
blocking | boolean | whether the bounding box of the internal space blocks placement of other items in the parent box. |
display | boolean | option to display the bounding box of the internal space as a white semi-transparent object in the visualization of its containing Item. |
displayChildren | boolean | option to display the children packed within the internal space in the visualization of its containing parent Box. |
{ "operation": "internal-space", "itemRefId": 0, "options": { "type": "subspace", "boxType": { "weightMax": 2, "name": "flower pot interior", "price": 0, "dimensions": { "x": 1.5, "y": 1.5, "z": 1.5 } }, "origin": { "x": 0.25, "y": 1, "z": 1 }, "blocking": true, "display": true, "displayChildren": true } }
Specify a set of alternate dimensions to attempt when packing in addition to the primary dimensions attribute of the item. Original dimensions can be replaced completely with replaceOriginal, typically used to apply general, label-based rules to decrease (as in folding) or increase (as in wrapping in packaging material) item dimensions in a generalized way. dimensionScaleChanges are candidate scale changes for each dimension, e.g., "x": -0.5 means reduce the "x" dimension by 50% (folded in half). Whereas, dimensionChanges refer to static changes in any matching item dimensions, e.g., "x": 1, "y": 1, "z": 1 means add one inch to each dimension of matching items.
"options" contents:
key | value | description |
---|---|---|
dimensions | []Point | A list of possible dimensions that will be attempted. Dimensions are sorted by volume ascending. |
dimensionChanges | []Point | A list of dimension change vectors that are added to the matching item dimensions to yield packing dimensions |
dimensionScaleChanges | []Point | A list of dimension scale-change vectors that are multiplied with the matching item dimensions, then added to the matching item dimensions to yield packing dimensions |
replaceOriginal | boolean | When true, the original dimensions from matching item dimensions are discarded, and only the alternate dimensions are considered. |
{ "operation": "alternate-dimensions", "itemRefId": 0, "options": { "dimensions": [{ "x": 6, "y": 8, "z": 16 }, { "x": 7.5, "y": 10, "z": 10 }], "dimensionChanges": [{ "x": 1.0, "y": 1.5, "z": 1.0 }], "dimensionScaleChanges": [{ "x": -0.5, "z": 0.1 }, { "x": 0.1, "y": 0.1, "z": 0.1 }] } }
itemRefId is excluded from being packed in the same carton with all targetItemRefIds, or in any carton found in targetBoxRefIds
{ "operation": "exclude", "itemRefId": 0, "targetItemRefIds": [1,2], "targetBoxRefIds": [3] }
itemRefId is excluded from being packed in the same carton with all items without its refId
{ "operation": "exclude-all", "itemRefId": 0 }
Each individual item with itemRefId is packed in a carton matching its exact dimensions, i.e., it is assumed the item is ship-ready and bypasses being placed in a box. If you have an item quantity of 6, it will place the items in 6 boxes.
{ "operation": "pack-as-is", "itemRefId": 0 }
There is one type of irregular item packing right now, "roll".
A rolled irregular item is simply where the item dimensions X, Y, and Z, represent the thickness, width, and total length of a material meant to be rolled up (possibly on a spool, dowel, etc.) and shipped as such. Marked this way, the bounding box of the roll cylinder will be used as its shipping dimensions. E.g., a roll has a width 60 inches and a diameter of 12 inches, it will be shipped as if it were a 12" x 12" x 60" item. Rolls can have a maximum allowable diameter, and any rolls that must be split will have their weights calculated on a pro-rated basis of the total length and weight in the item contents.
"options" contents:
key | value | description |
---|---|---|
type | "roll" | |
innerDiameter | number | the inner diameter of any dowel or tube used that serves as the initial diameter of the roll. |
spoolWeight | number | the additional weight of each spool or dowel if applicable |
maxDiameter | number | the maximum acceptable diameter of a resultant roll. |
maxWeight | number | the maximum acceptable weight of a resultant roll. |
minRollLength | number | the minimum length above which rolling will occur. E.g., if less than 12" remain, ship it flat without rolling. |
{ "operation": "irregular", "itemRefId": 0, "options": { "type": "roll", "innerDiameter": 1.0, "spoolWeight": 1.0, "maxDiameter": 8.0, "maxWeight": 150, "minRollLength": 12 } }
itemRefId is locked from rotation of its original dimensions, with axes of rotation excepted by freeAxes
"options" contents:
key | value | description |
---|---|---|
freeAxes | array | Array of axis indices to be allowed rotational freedom. E.g., [0] for only yaw allowed, [0,1] for yaw and roll. |
{ "operation": "lock-orientation", "itemRefId": 0, "options": { "freeAxes": [0,1] } }
itemRefId gains conditions for its packing and the packing of items directly above it. Fragile items can be wrapped in a thickness of packing material that is added to each face of the item, or marked as only to be packed on top of other items, or a maximum weight can be given for all additional items supported by the fragile item, or a simple priority flag can be specified where fraile items with the highest priority are never packed underneath items with a lower or unspecified priority.
"options" contents:
key | value | description |
---|---|---|
display | boolean | whether to display the virtual subspace created above fragile items for analysis purposes. |
maxWeight | number | the maximum weight of items that may be placed above this fragile item. |
onTopOnly | boolean | specifies that nothing will be placed between the top dimensions of this item and the top of the box or container it is packed within, overriding maxWeight if previously specified. |
excludeOverweight | boolean | automatically applies an item exclusion rule between this item and any items of a different refId with an item weight exceeding maxWeight. |
unrestrictedPlacement | boolean | when true, bypasses creation of a placement-restricting fragility subspace, above the item used in conjunction with excludeOverweight, packingMaterialThickness, or other non-placement-orientated fragility features (not compatible with onTopOnly.) |
onTopOnly | boolean | specifies that nothing will be placed between the top dimensions of this item and the top of the box or container it is packed within, overriding maxWeight if previously specified. |
packingMaterialThickness | number | FUTURE RELEASE—a thickness of padding to apply to each face of the fragile item. E.g., a 3"x3"x3" item with 0.5" of packingMaterialThickness will be packed as a 4"x4"x4" volume, as the 0.5" of material will be applied once to each of the top, bottom, front, back, left, and right sides. |
priority | number | FUTURE RELEASE—a priority integer, where higher values will never be placed underneath lower (or unspecified) values. |
{ "operation": "fragile", "itemRefId": 0, "options": { "display": false, "onTopOnly": false, "maxWeight": 5, "excludeOverweight": true, "unrestrictedPlacement": true, "packingMaterialThickness": 0.2, "priority": 0 } }
Matching items are to be packed by group based upon the options.
"options" contents:
key | value | description |
---|---|---|
type | enum | only 'auto' is currently supported |
nameSuffix | string | substring to append to all item names in group-pack |
scaleFactorThreshold | number | only apply axis multiplier to item axes at least 'scaleFactorThreshold' times smaller than the smallest availble 'boxType' dimension on that axis. |
axes | array | list of axes to potentially scale group-pack dimensions by |
axisMultiplier | int | for each permitted axis, scale the item dimensions (and the quantity group-packed) by 'axisMultiplier' |
{ "operation": "group-pack", "itemMatch": { "all": true }, "options": { "scaleFactorThreshold": 10, "axes": [0,1,2], "axisMultiplier": 8, "type": "auto", "nameSuffix": "auto-case-100" } }
cartonPrice = priceIncreaseRate * cartonWeight + basePriceOftentimes, this will be enough to get accurate carton selections without needing to send complete customer-based rates. It's worth considering, as the prices are only estimates to be used in carton selection, with final rating of cartons happening outside of paccurate. This is the predicted rate of increase for a weight-based pricing model. The simplest way to find a serviceable value is to take
priceIncreaseRate = (maximumPrice - minimumPrice)/(maximumWeight - minimumWeight)In the example above, this would yield
priceIncreaseRate = ($20-$10)/(3lbs-1lb)type: number basePrice: description: The basePrice can be found by estimating the lowest weight-based rate available for a given service, in the example above, solving for basePrice for a $10, 1lb package with the already-solved priceIncreaseRate yields
priceIncreaseRate = $10/2lbs
priceIncreaseRate = $5/lb
$10 = $5/lb * 1lb + basePricetype: number dimFactor: type: number description: This is the Dimensional Weight divisor. It is given in units of volume per unit weight, e.g., the standard of "139" represents 139 cubic inches per pound, and is used to convert the total volume of a carton into a functional minimum weight to be used when rating the carton. E.g., a carton with dimensions 10" x 10" x 13.9" would yield a volume of 1390 cubic inches. This yields
$10 = $5 + basePrice
basePrice = $5
cartonEffectiveMinimumWeight = 1390in³ / 139in³/lb. To disable when using a preset carrier and zone, set to -1 or a very big number. Subspace: type: object title: Subspace properties: originInParent: description: the coordinates of the origin of the current subspace translated into its immediate parent. allOf: - $ref: "#/definitions/Point" parentBoxIndex: description: the index (Box.id) of the subspace's parent box. type: integer parentItemIndex: description: the index (Item.index) of the subspace's parent item, if applicable. type: integer Image: type: object title: Image properties: boxIndex: description: the index (Box.id) of the box pack the image is a representation of. type: integer format: description: the image format of the data property. type: string enum: - svg - png data: description: base64-encoded image data. type: string
cartonEffectiveMinimumWeight = 10lbs