@infigo-official/types-for-pricing-script 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Infigo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,20 @@
+# Types for Pricing Script
+
+Type definitions for the Pricing Script scripting interface.
+
+Full documentation is available [here](https://infigo-official.github.io/types-for-pricing-script/).
+
+Use and install the package to get the best experience and IntelliSense support within our IDE.
+Choose dev dependencies if you are developing in Javascript or our code will not be reused in another project.
+
+```bash
+npm init
+
+# install as dev dependencies
+npm i -D @infigo-official/types-for-pricing-script
+
+# ... or ...
+
+# install as dependencies
+npm i @infigo-official/types-for-pricing-script
+``` 

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@infigo-official/types-for-pricing-script",
+  "version": "1.0.0",
+  "description": "Type definitions for Pricing Script Scripting",
+  "types": "v1/index.d.ts",
+  "devDependencies": {
+    "typedoc": "^0.26.6",
+    "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "docs": "npx typedoc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Infigo-Official/types-for-pricing-script.git"
+  },
+  "keywords": [
+    "typedefinitions",
+    "pricingscript",
+    "infigo"
+  ],
+  "author": "Infigo",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Infigo-Official/types-for-pricing-script/issues"
+  },
+  "homepage": "https://github.com/Infigo-Official/types-for-pricing-script#readme",
+  "files": [
+    "v1",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/v1/File/FileInfo.d.ts

@@ -0,0 +1,148 @@
+/**
+ * This module provides access to file information functionality in pricing scripts.
+ * The file handling system provides comprehensive information about uploaded files,
+ * allowing scripts to make pricing decisions based on file characteristics including:
+ * - File type and MIME type information
+ * - File size and dimensional data
+ * - Page count for multi-page documents
+ * - Content analysis for text-based files
+ * - Error handling for file processing
+ * 
+ * @module File
+ */
+
+/**
+ * Page size information for file dimensions.
+ * This interface provides dimensional data for individual pages
+ * within multi-page documents, useful for calculating costs based
+ * on document complexity and size.
+ */
+declare interface PageSize {
+    /**
+     * The width of the page in points.
+     * This value represents the horizontal dimension of the page
+     * and is used for calculating printing costs and layout considerations.
+     * 
+     * @example
+     * var pageWidth = pageSize.Width;
+     * var pageHeight = pageSize.Height;
+     * var pageArea = pageWidth * pageHeight;
+     */
+    Width: number;
+
+    /**
+     * The height of the page in points.
+     * This value represents the vertical dimension of the page
+     * and is used for calculating printing costs and layout considerations.
+     * 
+     * @example
+     * var pageWidth = pageSize.Width;
+     * var pageHeight = pageSize.Height;
+     * var pageArea = pageWidth * pageHeight;
+     */
+    Height: number;
+}
+
+/**
+ * Comprehensive file information object returned by getFileInfo methods.
+ * This interface provides detailed information about uploaded files,
+ * allowing pricing scripts to make decisions based on file characteristics
+ * such as size, type, dimensions, and content.
+ * 
+ * File information is essential for file-based pricing models where
+ * costs are calculated based on file properties rather than just
+ * product specifications.
+ */
+declare interface FileInfo {
+    /**
+     * The MIME type of the file.
+     * This value indicates the file format and type, allowing scripts
+     * to apply different pricing logic based on file type.
+     * 
+     * @example
+     * if (fileInfo.MimeType === "application/pdf") {
+     *     return Item.Price + (fileInfo.NumberOfPages * 0.50); // $0.50 per page
+     * } else if (fileInfo.MimeType.startsWith("image/")) {
+     *     return Item.Price + 2.00; // $2.00 for image files
+     * }
+     */
+    MimeType: string;
+
+    /**
+     * The size of the file in bytes.
+     * This value is used for size-based pricing models and to determine
+     * processing costs based on file complexity.
+     * 
+     * @example
+     * if (fileInfo.Size > 1024 * 1024) { // > 1MB
+     *     return Item.Price * 1.2; // 20% markup for large files
+     * }
+     */
+    Size: number;
+
+    /**
+     * The number of pages in the document.
+     * This value is only set for PDF attachments that can be parsed correctly
+     * and when the file size is within the 10 MB limitation.
+     * Used for page-based pricing models.
+     * 
+     * @example
+     * if (fileInfo.NumberOfPages > 0) {
+     *     return Item.Price + (fileInfo.NumberOfPages * 0.25); // $0.25 per page
+     * }
+     */
+    NumberOfPages: number;
+
+    /**
+     * Array of page size items, each having Width and Height properties.
+     * This array provides dimensional information for each page in the document,
+     * allowing for precise cost calculations based on page dimensions.
+     * 
+     * @example
+     * var totalArea = 0;
+     * for (var i = 0; i < fileInfo.Dimensions.length; i++) {
+     *     var page = fileInfo.Dimensions[i];
+     *     totalArea += page.Width * page.Height;
+     * }
+     * return Item.Price + (totalArea * 0.0001); // Cost based on total area
+     */
+    Dimensions: PageSize[];
+
+    /**
+     * The number of lines in a text/csv file.
+     * This value is only set when the readContent flag is set during
+     * file information retrieval. Used for line-based pricing models.
+     * 
+     * @example
+     * if (fileInfo.NumberOfRecords > 0) {
+     *     return Item.Price + (fileInfo.NumberOfRecords * 0.01); // $0.01 per line
+     * }
+     */
+    NumberOfRecords: number;
+
+    /**
+     * Array of lines with the text file content.
+     * This array is only set when the readContent flag is set and the file
+     * size is smaller than the 50KB limitation. Used for content-based pricing.
+     * 
+     * @example
+     * if (fileInfo.Content && fileInfo.Content.length > 0) {
+     *     var lineCount = fileInfo.Content.length;
+     *     return Item.Price + (lineCount * 0.005); // $0.005 per line
+     * }
+     */
+    Content: string[];
+
+    /**
+     * Error message indicating any issues encountered during file processing.
+     * This value is empty if retrieving file information was successful.
+     * Used for error handling and debugging file processing issues.
+     * 
+     * @example
+     * if (fileInfo.Error) {
+     *     error("File processing error: " + fileInfo.Error);
+     *     return Item.Price; // Fallback to base price
+     * }
+     */
+    Error: string;
+} 

package/v1/Helper/HelperMethods.d.ts

@@ -0,0 +1,141 @@
+/**
+ * CSV parsing options
+ */
+declare interface CsvOptions {
+    /**
+     * Delimiter character (default: ",")
+     */
+    delimiterChar?: string;
+
+    /**
+     * Quote character (default: '"')
+     */
+    quoteChar?: string;
+
+    /**
+     * Whether to disable number conversion (default: false)
+     */
+    disableNumberConverstion?: boolean;
+}
+
+/**
+ * CSV replacer function for stringify
+ */
+declare type CsvReplacer = (row: number, col: number, value: any) => any;
+
+/**
+ * CSV stringify options
+ */
+declare interface CsvStringifyOptions {
+    /**
+     * Delimiter character (default: ",")
+     */
+    delimiterChar?: string;
+
+    /**
+     * Quote character (default: '"')
+     */
+    quoteChar?: string;
+
+    /**
+     * Replacer function for custom value transformation
+     */
+    replacer?: CsvReplacer;
+}
+
+/**
+ * CSV helper methods
+ */
+declare interface CsvHelper {
+    /**
+     * Parse CSV string into array of arrays
+     * @param csv - CSV string to parse
+     * @param options - Parsing options
+     * @param disableNumberConversion - Whether to disable number conversion
+     * @returns Array of arrays representing the CSV data
+     */
+    parse(csv: string, options?: CsvOptions, disableNumberConversion?: boolean): any[][];
+
+    /**
+     * Convert array of arrays to CSV string
+     * @param table - Array of arrays to convert
+     * @param options - Stringify options
+     * @returns CSV string
+     */
+    stringify(table: any[][], options?: CsvStringifyOptions): string;
+}
+
+/**
+ * Helper methods available in pricing scripts
+ */
+declare interface HelperMethods {
+    /**
+     * Find the appropriate tier based on quantity and customer roles
+     * @param quantity - The quantity to find tier for
+     * @param tiers - Array of tier objects
+     * @param roles - Array of customer role system names
+     * @returns Tier object or null if no tier found
+     */
+    FindTier(quantity: number, tiers: Tier[], roles?: string[]): Tier | null;
+
+    /**
+     * Get attribute price adjustments including tier price adjustments
+     * @param quantity - The quantity to get adjustments for
+     * @param roles - Array of customer role system names
+     * @returns Total price adjustment
+     */
+    GetAttributePriceAdjustment(quantity: number, roles?: string[]): number;
+
+    /**
+     * Interpolate price based on quantity and tiers
+     * @param quantity - The quantity to interpolate price for
+     * @param tiers - Array of tier objects
+     * @returns Interpolated price
+     */
+    InterpolatePrice(quantity: number, tiers: Tier[]): number;
+
+    /**
+     * Log all properties of an object to console
+     * @param data - Object to log
+     */
+    LogObject(data: any): void;
+
+    /**
+     * Check if an array contains a specific value
+     * @param array - Array to check
+     * @param value - Value to search for
+     * @returns Whether the value is found
+     */
+    Contains(array: any[], value: any): boolean;
+
+    /**
+     * Check if an item is an object
+     * @param item - Item to check
+     * @returns Whether the item is an object
+     */
+    IsObject(item: any): boolean;
+
+    /**
+     * Check if an item is an array
+     * @param item - Item to check
+     * @returns Whether the item is an array
+     */
+    IsArray(item: any): boolean;
+
+    /**
+     * Merge source object into target object
+     * @param target - Target object to merge into
+     * @param source - Source object to merge from
+     */
+    MergeObject(target: any, source: any): void;
+
+    /**
+     * CSV parsing and stringifying utilities
+     */
+    CSV: CsvHelper;
+}
+
+/**
+ * Global HelperMethods object
+ */
+declare const HelperMethods: HelperMethods; 

package/v1/Item/Attribute.d.ts

@@ -0,0 +1,281 @@
+/**
+ * This module provides access to attribute management functionality in pricing scripts.
+ * Attributes represent configurable options for products that can affect pricing, weight, and dimensions.
+ * The attribute system provides a flexible way to handle complex product configurations including:
+ * - Product options and variants
+ * - Price adjustments based on selections
+ * - Weight and dimensional modifications
+ * - Tier-based pricing adjustments
+ * - Required vs optional attributes
+ * 
+ * @module Item / Attribute
+ */
+
+/**
+ * Represents an individual value within an attribute.
+ * Attribute values define the specific options available for a product attribute,
+ * including their pricing implications and physical adjustments.
+ * 
+ * Each attribute value can have its own price, weight, and dimensional adjustments,
+ * allowing for precise control over how product options affect the final pricing.
+ */
+declare interface AttributeValue {
+    /**
+     * The display value of the attribute option as shown to customers.
+     * This is the human-readable text that appears in the user interface
+     * for this specific attribute option.
+     * 
+     * @example
+     * var selectedColor = attr.Value; // "Red", "Blue", "Green", etc.
+     */
+    Value: string;
+
+    /**
+     * The unique identifier for this attribute value.
+     * This ID is used internally for tracking and processing attribute selections
+     * and should not be displayed to end users.
+     * 
+     * @example
+     * var valueId = attr.Id; // "color_red_001", "size_large_002", etc.
+     */
+    Id: string;
+
+    /**
+     * The price adjustment amount for this attribute value.
+     * This value is added to or subtracted from the base product price
+     * when this attribute value is selected.
+     * 
+     * @example
+     * var finalPrice = Item.Price + attr.PriceAdjustment;
+     */
+    PriceAdjustment: number;
+
+    /**
+     * The weight adjustment amount for this attribute value.
+     * This value is added to or subtracted from the base product weight
+     * when this attribute value is selected, affecting shipping calculations.
+     * 
+     * @example
+     * var adjustedWeight = Item.Weight + attr.WeightAdjustment;
+     */
+    WeightAdjustment: number;
+
+    /**
+     * The length adjustment amount for this attribute value.
+     * This value modifies the product's length dimension when this
+     * attribute value is selected, affecting packaging calculations.
+     * 
+     * @example
+     * var adjustedLength = Item.Length + attr.LengthAdjustment;
+     */
+    LengthAdjustment: number;
+
+    /**
+     * The width adjustment amount for this attribute value.
+     * This value modifies the product's width dimension when this
+     * attribute value is selected, affecting packaging calculations.
+     * 
+     * @example
+     * var adjustedWidth = Item.Width + attr.WidthAdjustment;
+     */
+    WidthAdjustment: number;
+
+    /**
+     * The height adjustment amount for this attribute value.
+     * This value modifies the product's height dimension when this
+     * attribute value is selected, affecting packaging calculations.
+     * 
+     * @example
+     * var adjustedHeight = Item.Height + attr.HeightAdjustment;
+     */
+    HeightAdjustment: number;
+
+    /**
+     * Indicates whether the price adjustment should be applied as a percentage
+     * rather than a fixed amount. When true, the PriceAdjustment value is
+     * treated as a percentage of the base price.
+     * 
+     * @example
+     * if (attr.PriceAdjustmentIsPercentage) {
+     *     var adjustment = Item.Price * (attr.PriceAdjustment / 100);
+     * } else {
+     *     var adjustment = attr.PriceAdjustment;
+     * }
+     */
+    PriceAdjustmentIsPercentage: boolean;
+
+    /**
+     * Indicates whether tier-based price adjustments should be used for this attribute value.
+     * When true, the system will use the TierPriceAdjustments array instead of
+     * the standard PriceAdjustment for quantity-based pricing.
+     * 
+     * @example
+     * if (attr.UseTierPriceAdjustment) {
+     *     var tierAdjustment = HelperMethods.FindTier(Item.Quantity, attr.TierPriceAdjustments);
+     * }
+     */
+    UseTierPriceAdjustment: boolean;
+
+    /**
+     * Array of tier-based price adjustments for this attribute value.
+     * Each tier defines a quantity threshold and corresponding price adjustment,
+     * allowing for quantity-based pricing variations for this specific attribute option.
+     * 
+     * @example
+     * var tierAdjustment = HelperMethods.FindTier(Item.Quantity, attr.TierPriceAdjustments);
+     * if (tierAdjustment) {
+     *     var finalPrice = Item.Price + tierAdjustment.Price;
+     * }
+     */
+    TierPriceAdjustments: Tier[];
+}
+
+/**
+ * Represents a product attribute with its configuration and available values.
+ * Attributes define the configurable options for a product, such as color, size,
+ * material, or any other product variant that affects pricing or specifications.
+ * 
+ * Each attribute contains a collection of possible values and defines how
+ * those values affect the product's pricing, weight, and dimensions.
+ */
+declare interface Attribute {
+    /**
+     * The unique key or name identifier for this attribute.
+     * This is used internally to identify the attribute and should be
+     * consistent across different product configurations.
+     * 
+     * @example
+     * var attrKey = attr.Key; // "color", "size", "material", etc.
+     */
+    Key: string;
+
+    /**
+     * The display text shown to customers when selecting this attribute.
+     * This is the human-readable label that appears in the user interface
+     * to describe what this attribute represents.
+     * 
+     * @example
+     * var prompt = attr.Prompt; // "Select Color", "Choose Size", etc.
+     */
+    Prompt: string;
+
+    /**
+     * Indicates whether this attribute must be selected before the product
+     * can be added to the cart. Required attributes typically represent
+     * essential product specifications.
+     * 
+     * @example
+     * if (attr.IsRequired && !attr.Value) {
+     *     error("Please select a " + attr.Prompt);
+     * }
+     */
+    IsRequired: boolean;
+
+    /**
+     * The currently selected value for this attribute.
+     * This represents the customer's choice for this attribute option.
+     * Empty string indicates no selection has been made.
+     * 
+     * @example
+     * var selectedValue = attr.Value; // "Red", "Large", "Premium", etc.
+     */
+    Value: string;
+
+    /**
+     * The price adjustment amount for the currently selected attribute value.
+     * This value is calculated based on the selected AttributeValue and
+     * represents the total price impact of this attribute selection.
+     * 
+     * @example
+     * var totalPrice = Item.Price + attr.PriceAdjustment;
+     */
+    PriceAdjustment: number;
+
+    /**
+     * The weight adjustment amount for the currently selected attribute value.
+     * This value represents the total weight impact of this attribute selection,
+     * affecting shipping and handling calculations.
+     * 
+     * @example
+     * var totalWeight = Item.Weight + attr.WeightAdjustment;
+     */
+    WeightAdjustment: number;
+
+    /**
+     * Indicates whether the price adjustment should be applied as a percentage
+     * rather than a fixed amount. When true, the PriceAdjustment value is
+     * treated as a percentage of the base price.
+     * 
+     * @example
+     * if (attr.PriceAdjustmentIsPercentage) {
+     *     var adjustment = Item.Price * (attr.PriceAdjustment / 100);
+     * } else {
+     *     var adjustment = attr.PriceAdjustment;
+     * }
+     */
+    PriceAdjustmentIsPercentage: boolean;
+
+    /**
+     * The type or category of this attribute.
+     * This defines the kind of attribute (e.g., "color", "size", "material")
+     * and may affect how the attribute is displayed or processed.
+     * 
+     * @example
+     * if (attr.Type === "color") {
+     *     // Handle color-specific logic
+     * }
+     */
+    Type: string;
+
+    /**
+     * The unique numeric identifier for this attribute.
+     * This ID is used internally for database operations and system processing.
+     * 
+     * @example
+     * var attrId = attr.Id; // 1, 2, 3, etc.
+     */
+    Id: number;
+
+    /**
+     * Array of all possible values available for this attribute.
+     * Each value represents a selectable option with its own pricing
+     * and adjustment implications.
+     * 
+     * @example
+     * for (var i = 0; i < attr.Values.length; i++) {
+     *     var option = attr.Values[i];
+     *     console.log(option.Value + ": $" + option.PriceAdjustment);
+     * }
+     */
+    Values: AttributeValue[];
+
+    /**
+     * The length adjustment amount for the currently selected attribute value.
+     * This value represents the total length impact of this attribute selection,
+     * affecting packaging and dimensional calculations.
+     * 
+     * @example
+     * var totalLength = Item.Length + attr.LengthAdjustment;
+     */
+    LengthAdjustment: number;
+
+    /**
+     * The width adjustment amount for the currently selected attribute value.
+     * This value represents the total width impact of this attribute selection,
+     * affecting packaging and dimensional calculations.
+     * 
+     * @example
+     * var totalWidth = Item.Width + attr.WidthAdjustment;
+     */
+    WidthAdjustment: number;
+
+    /**
+     * The height adjustment amount for the currently selected attribute value.
+     * This value represents the total height impact of this attribute selection,
+     * affecting packaging and dimensional calculations.
+     * 
+     * @example
+     * var totalHeight = Item.Height + attr.HeightAdjustment;
+     */
+    HeightAdjustment: number;
+} 

package/v1/Item/Item.d.ts

@@ -0,0 +1,362 @@
+/**
+ * This module provides access to the main item object in pricing scripts.
+ * The Item interface represents the product variant being priced and contains all
+ * the essential information needed for pricing calculations including:
+ * - Product pricing information (base price, special prices, costs)
+ * - Product details (SKU, name, categories, dimensions)
+ * - Quantity and packaging information
+ * - Attribute management and pricing adjustments
+ * - File handling capabilities
+ * - Tier-based pricing support
+ * 
+ * @module Item
+ */
+
+/**
+ * The main item object available in pricing scripts.
+ * Represents the product variant being priced and provides access to all
+ * product information, attributes, pricing data, and methods for file handling
+ * and attribute management.
+ * 
+ * This object is the primary interface for accessing product data and performing
+ * pricing calculations in pricing scripts.
+ */
+declare interface Item {
+    /**
+     * The standard product variant price in the base currency.
+     * This is the base price before any attribute adjustments, tier pricing,
+     * or special pricing is applied.
+     * 
+     * @example
+     * var basePrice = Item.Price;
+     * var adjustedPrice = basePrice * 1.2; // 20% markup
+     */
+    Price: number;
+
+    /**
+     * The old price from the product variant, typically used for displaying
+     * price comparisons or discounts. This value represents the previous
+     * price before any recent price changes.
+     * 
+     * @example
+     * if (Item.OldPrice > Item.Price) {
+     *     var discount = Item.OldPrice - Item.Price;
+     *     return "Save $" + discount.toFixed(2);
+     * }
+     */
+    OldPrice: number;
+
+    /**
+     * The product cost, representing the actual cost to produce or acquire
+     * the product. This value is used for margin calculations and profit analysis.
+     * 
+     * @example
+     * var margin = Item.Price - Item.ProductCost;
+     * var marginPercentage = (margin / Item.Price) * 100;
+     */
+    ProductCost: number;
+
+    /**
+     * The special price for the product variant, if applicable.
+     * This value is null if no special pricing is currently active.
+     * Special pricing typically overrides the standard price for promotional periods.
+     * 
+     * @example
+     * var finalPrice = Item.SpecialPrice || Item.Price;
+     */
+    SpecialPrice: number | null;
+
+    /**
+     * The start date for special pricing, if applicable.
+     * This value is null if no special pricing is currently active.
+     * Used to determine if special pricing should be applied based on current date.
+     * 
+     * @example
+     * var now = new Date();
+     * if (Item.SpecialPriceStartDate && now >= Item.SpecialPriceStartDate) {
+     *     return Item.SpecialPrice;
+     * }
+     */
+    SpecialPriceStartDate: Date | null;
+
+    /**
+     * The end date for special pricing, if applicable.
+     * This value is null if no special pricing is currently active.
+     * Used to determine if special pricing should be applied based on current date.
+     * 
+     * @example
+     * var now = new Date();
+     * if (Item.SpecialPriceEndDate && now <= Item.SpecialPriceEndDate) {
+     *     return Item.SpecialPrice;
+     * }
+     */
+    SpecialPriceEndDate: Date | null;
+
+    /**
+     * Additional shipping charge for this specific product variant.
+     * This value is added to the base shipping cost and represents
+     * any extra shipping fees specific to this item.
+     * 
+     * @example
+     * var totalShipping = baseShippingCost + Item.AdditionalShippingCharge;
+     */
+    AdditionalShippingCharge: number;
+
+    /**
+     * The weight of the item in the configured weight unit (typically grams or ounces).
+     * This value is used for shipping calculations and weight-based pricing.
+     * 
+     * @example
+     * var shippingCost = calculateShippingByWeight(Item.Weight);
+     */
+    Weight: number;
+
+    /**
+     * Indicates whether the weight can be set or modified for this item.
+     * Some products may have fixed weights that cannot be changed,
+     * while others allow weight adjustments based on attributes or custom settings.
+     * 
+     * @example
+     * if (Item.CanSetWeight) {
+     *     // Allow weight adjustments in the UI
+     * }
+     */
+    CanSetWeight: boolean;
+
+    /**
+     * The Stock Keeping Unit (SKU) of the product variant.
+     * This is the unique identifier for the product variant and is used
+     * for inventory management and order processing.
+     * 
+     * @example
+     * var productIdentifier = Item.Sku;
+     */
+    Sku: string;
+
+    /**
+     * The actual SKU based on the current attribute combination.
+     * If no attributes are selected, this will be the same as the product SKU.
+     * This value reflects the specific configuration of the product being priced.
+     * 
+     * @example
+     * var configuredSku = Item.ActualSku;
+     */
+    ActualSku: string;
+
+    /**
+     * The width of the item in the configured dimension unit (typically inches or centimeters).
+     * This value is used for packaging calculations and dimensional pricing.
+     * 
+     * @example
+     * var packagingCost = calculatePackagingCost(Item.Width, Item.Height, Item.Length);
+     */
+    Width: number;
+
+    /**
+     * The height of the item in the configured dimension unit (typically inches or centimeters).
+     * This value is used for packaging calculations and dimensional pricing.
+     * 
+     * @example
+     * var packagingCost = calculatePackagingCost(Item.Width, Item.Height, Item.Length);
+     */
+    Height: number;
+
+    /**
+     * The length of the item in the configured dimension unit (typically inches or centimeters).
+     * This value is used for packaging calculations and dimensional pricing.
+     * 
+     * @example
+     * var packagingCost = calculatePackagingCost(Item.Width, Item.Height, Item.Length);
+     */
+    Length: number;
+
+    /**
+     * The name of the product as displayed to customers.
+     * This is the human-readable product name used in the user interface
+     * and order confirmations.
+     * 
+     * @example
+     * var displayName = Item.ProductName;
+     */
+    ProductName: string;
+
+    /**
+     * Array of category names that this product belongs to.
+     * Categories are used for product organization, filtering, and
+     * category-specific pricing rules.
+     * 
+     * @example
+     * if (Item.Categories.includes("Premium")) {
+     *     return Item.Price * 1.1; // 10% premium markup
+     * }
+     */
+    Categories: string[];
+
+    /**
+     * The order quantity for this item.
+     * This represents how many units of this product variant are being ordered.
+     * Used for quantity-based pricing and tier calculations.
+     * 
+     * @example
+     * var tier = HelperMethods.FindTier(Item.Quantity, Item.PricingTiers);
+     */
+    Quantity: number;
+
+    /**
+     * The pack quantity, calculated as the order quantity divided by the product variant's
+     * OrderPackQuantity. This represents how many packs are being ordered.
+     * 
+     * @example
+     * var packPrice = Item.Price * Item.PackQuantity;
+     */
+    PackQuantity: number;
+
+    /**
+     * The quantity selector mode for this product.
+     * This determines how quantity selection is handled in the user interface
+     * and affects pricing calculations.
+     * 
+     * @example
+     * switch (Item.QuantitySelectorMode) {
+     *     case 1: // Individual units
+     *         return Item.Price * Item.Quantity;
+     *     case 2: // Packs
+     *         return Item.Price * Item.PackQuantity;
+     * }
+     */
+    QuantitySelectorMode: number;
+
+    /**
+     * Whether this is a batch job
+     */
+    IsBatch: boolean;
+
+    /**
+     * Number of pages (-1 if not valid)
+     */
+    NumberOfPages: number;
+
+    /**
+     * Number of records (-1 if not valid)
+     */
+    NumberOfRecords: number;
+
+    /**
+     * Array of pricing tiers with Price, Quantity, and CustomerRole
+     */
+    PricingTiers: Tier[];
+
+    /**
+     * Array of batch tiers (same as PricingTiers but for batch tier table)
+     */
+    BatchTiers: Tier[];
+
+    /**
+     * Price per record (-1 if not valid)
+     */
+    PricePerRecord: number;
+
+    /**
+     * Array of attributes with Key, Value, IsRequired, Prompt, PriceAdjustment, etc.
+     */
+    Attributes: Attribute[];
+
+    /**
+     * User email
+     */
+    Email: string;
+
+    /**
+     * Array of customer role system names
+     */
+    CustomerRoles: string[];
+
+    /**
+     * Department name of user
+     */
+    Department: string;
+
+    /**
+     * Array of other order items using the same custom pricing script
+     */
+    OtherOrderItems: Item[];
+
+    /**
+     * Alias of OtherOrderItems
+     */
+    CartItems: Item[];
+
+    /**
+     * Index of this item in the other order item array (0 if not in array)
+     */
+    OrderItemIndex: number;
+
+    /**
+     * Index of this item in the other order item array (-1 if not in array)
+     */
+    CartItemIndex: number;
+
+    /**
+     * Whether this item is in the other order item array
+     */
+    IsInOtherOrderItems: boolean;
+
+    /**
+     * Value of the currently used discount code
+     */
+    DiscountCode: string;
+
+    /**
+     * Array of versions with JobId, CustomName, and Quantity
+     */
+    Versions: ItemVersion[];
+
+    /**
+     * Number of versions
+     */
+    NumberOfVersions: number;
+
+    /**
+     * Whether this is a version of a job
+     */
+    IsVersion: boolean;
+
+    /**
+     * Sum of all quantities of all versions
+     */
+    VersionsSumQuantity: number;
+
+    /**
+     * Get file information for attached files
+     * @param attributeId - ID of the attribute
+     * @param readContent - Whether to read file content
+     * @returns FileInfo object
+     */
+    getFileInfo(attributeId: string, readContent: boolean): FileInfo;
+
+    /**
+     * Shortcut method to retrieve an attribute value by name
+     * @param attribute - Name of the attribute
+     * @returns Attribute value
+     */
+    getAttributeValue(attribute: string): string;
+
+    /**
+     * Set the attribute value permanently to the given value
+     * @param attribute - Name of the attribute
+     * @param value - Value to set
+     */
+    setAttributeValue(attribute: string, value: string): void;
+
+    /**
+     * Get file information for a specific configurable file from Global Data
+     * @param filename - Name of the file
+     * @returns FileInfo object
+     */
+    getGlobalFileContent(filename: string): FileInfo;
+}
+
+/**
+ * Global Item object
+ */
+declare const Item: Item; 

package/v1/Item/Tier.d.ts

@@ -0,0 +1,62 @@
+/**
+ * This module provides access to tier-based pricing functionality in pricing scripts.
+ * The tier system supports sophisticated quantity-based pricing models that can
+ * account for quantity discounts and customer-specific pricing including:
+ * - Quantity-based pricing tiers
+ * - Customer role-specific pricing
+ * - Volume discount calculations
+ * - Tier boundary management
+ * 
+ * @module Item / Tier
+ */
+
+/**
+ * Represents a pricing tier for quantity-based pricing.
+ * Pricing tiers define quantity thresholds and corresponding prices,
+ * allowing for volume discounts and quantity-based pricing variations.
+ * 
+ * Each tier specifies a minimum quantity threshold and the price that
+ * applies when the order quantity meets or exceeds that threshold.
+ * Tiers can also be restricted to specific customer roles for
+ * role-based pricing strategies.
+ */
+declare interface Tier {
+    /**
+     * The quantity threshold for this tier.
+     * This value represents the minimum quantity required to qualify
+     * for this pricing tier. When the order quantity meets or exceeds
+     * this threshold, the tier's price is applied.
+     * 
+     * @example
+     * if (Item.Quantity >= tier.Quantity) {
+     *     return tier.Price; // Use tier pricing
+     * }
+     */
+    Quantity: number;
+
+    /**
+     * The price for this tier.
+     * This value represents the unit price that applies when the order
+     * quantity meets or exceeds the tier's quantity threshold.
+     * 
+     * @example
+     * var tier = HelperMethods.FindTier(Item.Quantity, Item.PricingTiers);
+     * if (tier) {
+     *     return tier.Price * Item.Quantity;
+     * }
+     */
+    Price: number;
+
+    /**
+     * The customer role system name that this tier applies to.
+     * This value is empty when the tier applies to all customer roles.
+     * When specified, the tier only applies to customers with the
+     * specified role, allowing for role-based pricing strategies.
+     * 
+     * @example
+     * if (tier.CustomerRole === "" || Customer.CustomerRoles.includes(tier.CustomerRole)) {
+     *     return tier.Price; // Tier applies to this customer
+     * }
+     */
+    CustomerRole: string;
+} 

package/v1/Item/Version.d.ts

@@ -0,0 +1,130 @@
+/**
+ * This module provides access to version management functionality in pricing scripts.
+ * The version system supports job versioning information including quantities
+ * and custom names, useful for tracking pricing changes across job iterations including:
+ * - Individual version information
+ * - Version collection management
+ * - Quantity tracking across versions
+ * - Version status and metadata
+ * 
+ * @module Item / Version
+ */
+
+/**
+ * Represents individual version item information.
+ * Each version item contains details about a specific version of a job,
+ * including its unique identifier, custom name, and quantity information.
+ * 
+ * Version items are used to track different iterations or variations
+ * of the same job, allowing for complex pricing scenarios where
+ * multiple versions of a product are being ordered simultaneously.
+ */
+declare interface ItemVersion {
+    /**
+     * The job ID for this version.
+     * This unique identifier links this version to a specific job
+     * in the system, allowing for tracking and management of
+     * individual version instances.
+     * 
+     * @example
+     * var versionJobId = version.JobId;
+     * console.log("Processing version with job ID: " + versionJobId);
+     */
+    JobId: string;
+
+    /**
+     * The custom name for this version.
+     * This human-readable identifier allows users to distinguish
+     * between different versions of the same job, such as
+     * "Draft Version", "Final Version", or "Client Approved".
+     * 
+     * @example
+     * var versionName = version.CustomName;
+     * if (versionName.includes("Final")) {
+     *     return Item.Price * 1.1; // 10% markup for final versions
+     * }
+     */
+    CustomName: string;
+
+    /**
+     * The quantity for this version.
+     * This value represents how many units of this specific version
+     * are being ordered, allowing for version-specific quantity
+     * calculations and pricing adjustments.
+     * 
+     * @example
+     * var versionQuantity = version.Quantity;
+     * var versionTotal = Item.Price * versionQuantity;
+     */
+    Quantity: number;
+}
+
+/**
+ * Represents version data containing comprehensive version information.
+ * This interface provides access to version collection management,
+ * version status tracking, and aggregate quantity calculations
+ * across all versions of a job.
+ * 
+ * Version data is essential for complex pricing scenarios where
+ * multiple versions of a product are being processed together,
+ * allowing for bulk pricing and version-specific adjustments.
+ */
+declare interface VersionData {
+    /**
+     * Collection of version items.
+     * This array contains all individual version items associated
+     * with the current job, providing access to detailed information
+     * about each version including quantities and custom names.
+     * 
+     * @example
+     * var totalPrice = 0;
+     * for (var i = 0; i < versionData.Versions.length; i++) {
+     *     var version = versionData.Versions[i];
+     *     totalPrice += Item.Price * version.Quantity;
+     * }
+     * return totalPrice;
+     */
+    Versions: ItemVersion[];
+
+    /**
+     * Indicates whether this is a version of a job.
+     * This boolean flag determines if the current job is part of
+     * a versioned workflow, affecting how pricing calculations
+     * and business logic should be applied.
+     * 
+     * @example
+     * if (versionData.IsVersion) {
+     *     // Apply version-specific pricing logic
+     *     return calculateVersionPricing(versionData);
+     * }
+     */
+    IsVersion: boolean;
+
+    /**
+     * The number of versions in the collection.
+     * This value provides a quick count of how many versions
+     * are associated with the current job, useful for bulk
+     * pricing calculations and version management.
+     * 
+     * @example
+     * if (versionData.NumberOfVersions > 1) {
+     *     return Item.Price * 0.95; // 5% discount for multiple versions
+     * }
+     */
+    NumberOfVersions: number;
+
+    /**
+     * The sum of all quantities across all versions.
+     * This value represents the total quantity being ordered
+     * across all versions of the job, useful for bulk pricing
+     * and quantity-based discount calculations.
+     * 
+     * @example
+     * var totalQuantity = versionData.VersionsSumQuantity;
+     * var tier = HelperMethods.FindTier(totalQuantity, Item.PricingTiers);
+     * if (tier) {
+     *     return tier.Price * totalQuantity;
+     * }
+     */
+    VersionsSumQuantity: number;
+}

package/v1/System/Configuration.d.ts

@@ -0,0 +1,48 @@
+/**
+ * This module provides access to configuration settings in pricing scripts.
+ * The Configuration object allows scripts to access and utilize various
+ * configuration parameters that control script behavior including:
+ * - Script-specific configuration settings
+ * - Environment variables and parameters
+ * - Custom configuration data
+ * - System-wide settings
+ * 
+ * @module System / Configuration
+ */
+
+/**
+ * Provides access to script configuration settings and parameters.
+ * This interface allows pricing scripts to retrieve configuration data
+ * that controls their behavior and functionality.
+ * 
+ * Configuration settings can include script-specific parameters,
+ * environment variables, and custom configuration data that affects
+ * how the pricing script operates.
+ */
+declare interface ConfigurationInterface {
+    /**
+     * The script configuration object containing all configuration settings.
+     * This object holds various configuration parameters that can be used
+     * to customize script behavior and access external configuration data.
+     * 
+     * The structure of this object depends on the specific configuration
+     * settings defined for the pricing script.
+     * 
+     * @example
+     * var config = Configuration.ScriptConfig;
+     * var markupPercentage = config.markupPercentage || 20;
+     * var baseShippingCost = config.baseShippingCost || 5.99;
+     */
+    ScriptConfig: any;
+}
+
+/**
+ * Global Configuration object available in pricing scripts.
+ * This constant provides access to the configuration interface,
+ * allowing scripts to retrieve configuration settings and parameters.
+ * 
+ * @example
+ * var scriptConfig = Configuration.ScriptConfig;
+ * var customSetting = scriptConfig.customParameter;
+ */
+declare const Configuration: ConfigurationInterface; 

package/v1/System/Output.d.ts

@@ -0,0 +1,81 @@
+/**
+ * This module provides access to output and messaging functionality in pricing scripts.
+ * The output functions allow scripts to communicate with users and provide feedback
+ * about pricing calculations and decisions including:
+ * - Debug messages for development and troubleshooting
+ * - Alert messages for important information
+ * - Warning messages for potential issues
+ * - Error messages for calculation failures
+ * - Console logging for debugging purposes
+ * 
+ * @module System / Output
+ */
+
+/**
+ * Output a debug message to the user interface.
+ * Debug messages are typically used during development and troubleshooting
+ * to provide detailed information about script execution and calculations.
+ * 
+ * @param message - The debug message to display to the user
+ * 
+ * @example
+ * debug("Calculating price for item: " + Item.ProductName);
+ * debug("Base price: $" + Item.Price + ", Quantity: " + Item.Quantity);
+ */
+declare function debug(message: string): void;
+
+/**
+ * Output an alert message to the user interface.
+ * Alert messages are used to display important information that requires
+ * user attention, such as pricing changes or special offers.
+ * 
+ * @param message - The alert message to display to the user
+ * 
+ * @example
+ * alert("Special pricing applied: 20% discount for bulk orders");
+ * alert("Price updated based on selected attributes");
+ */
+declare function alert(message: string): void;
+
+/**
+ * Output a warning message to the user interface.
+ * Warning messages are used to notify users about potential issues
+ * or important considerations that may affect their pricing.
+ * 
+ * @param message - The warning message to display to the user
+ * 
+ * @example
+ * warning("Large file detected - processing may take longer");
+ * warning("Some attributes may affect shipping costs");
+ */
+declare function warning(message: string): void;
+
+/**
+ * Output an error message to the user interface.
+ * Error messages are used to inform users about calculation failures
+ * or other issues that prevent normal pricing execution.
+ * 
+ * @param message - The error message to display to the user
+ * 
+ * @example
+ * error("Unable to calculate price - missing required attributes");
+ * error("File processing failed - please check file format");
+ */
+declare function error(message: string): void;
+
+/**
+ * Output a message to the browser console/logs.
+ * Console messages are used for debugging purposes and are typically
+ * only visible to developers in the browser's developer tools.
+ * 
+ * @param message - The message to log to the console
+ * 
+ * @example
+ * consoleLog("Script execution started");
+ * consoleLog("Final calculated price: $" + finalPrice);
+ */
+declare function consoleLog(message: string): void;
+
+
+
+ 

package/v1/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="Item/Item.d.ts" />
+/// <reference path="Item/Attribute.d.ts" />
+/// <reference path="Item/Tier.d.ts" />
+/// <reference path="Item/Version.d.ts" />
+/// <reference path="File/FileInfo.d.ts" />
+/// <reference path="System/Configuration.d.ts" />
+/// <reference path="System/Output.d.ts" />
+/// <reference path="Helper/HelperMethods.d.ts" />