@salesforce/b2c-cli 1.10.0 → 1.12.0

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/Decimal.d.ts

@@ -0,0 +1,148 @@
+/**
+ * The Decimal class is a helper class to perform decimal arithmetic in
+ * scripts and to represent a decimal number with arbitrary length. The decimal
+ * class avoids arithmetic errors, which are typical for calculating with
+ * floating numbers, that are based on a binary mantissa.
+ * 
+ * The class is designed in a way that it can be used very similar to a
+ * desktop calculator.
+ * 
+ * ```
+ * var d = new Decimal( 10.0 );
+ * var result = d.add( 2.0 ).sub( 3.0 ).get();
+ * ```
+ * 
+ * The above code will return 9 as result.
+ */
+declare class Decimal {
+    /**
+     * Constructs a new Decimal with the value 0.
+     */
+    constructor();
+    /**
+     * Constructs a new decimal using the specified Number value.
+     */
+    constructor(value: number);
+    /**
+     * Constructs a new decimal using the specified BigInt value.
+     * @since 22.7
+     */
+    constructor(value: bigint);
+    /**
+     * Constructs a new Decimal using the specified string representation of
+     * a number.
+     */
+    constructor(value: string);
+    /**
+     * Returns a new Decimal with the absolute value of this Decimal.
+     */
+    abs(): Decimal;
+    /**
+     * Adds a Number value to this Decimal and returns the new Decimal.
+     */
+    add(value: number): Decimal;
+    /**
+     * Adds a Decimal value to this Decimal and returns the new Decimal.
+     */
+    add(value: Decimal): Decimal;
+    /**
+     * Adds a percentage value to the current value of the
+     * decimal. For example a value of 10 represent 10% or a value of
+     * 85 represents 85%.
+     */
+    addPercent(value: number): Decimal;
+    /**
+     * Adds a percentage value to the current value of the
+     * decimal. For example a value of 10 represent 10% or a value of
+     * 85 represents 85%.
+     */
+    addPercent(value: Decimal): Decimal;
+    /**
+     * Divides the specified Number value with this decimal and returns the new
+     * decimal.
+     * 
+     * When performing the division, 34 digits precision and a rounding mode of
+     * HALF_EVEN is used to prevent quotients with nonterminating decimal
+     * expansions.
+     */
+    divide(value: number): Decimal;
+    /**
+     * Divides the specified Decimal value with this decimal and returns the new
+     * decimal.
+     * 
+     * When performing the division, 34 digits precision and a rounding mode of
+     * HALF_EVEN is used to prevent quotients with nonterminating decimal
+     * expansions.
+     */
+    divide(value: Decimal): Decimal;
+    /**
+     * Compares two decimal values whether they are equivalent.
+     */
+    equals(other: any): boolean;
+    /**
+     * Returns the value of the Decimal as a Number.
+     */
+    get(): number;
+    /**
+     * Calculates the hash code for this decimal;
+     */
+    hashCode(): number;
+    /**
+     * Multiples the specified Number value with this Decimal and returns the new Decimal.
+     */
+    multiply(value: number): Decimal;
+    /**
+     * Multiples the specified Decimal value with this Decimal and returns the new Decimal.
+     */
+    multiply(value: Decimal): Decimal;
+    /**
+     * Returns a new Decimal with the negated value of this Decimal.
+     */
+    negate(): Decimal;
+    /**
+     * Rounds the current value of the decimal using the specified
+     * number of decimals. The parameter
+     * specifies the number of digest after the decimal point.
+     */
+    round(decimals: number): Decimal;
+    /**
+     * Subtracts the specified Number value from this Decimal and returns the new Decimal.
+     */
+    subtract(value: number): Decimal;
+    /**
+     * Subtracts the specified Decimal value from this Decimal and returns the new Decimal.
+     */
+    subtract(value: Decimal): Decimal;
+    /**
+     * Subtracts a percentage value from the current value of the
+     * decimal. For example a value of 10 represent 10% or a value of
+     * 85 represents 85%.
+     */
+    subtractPercent(value: number): Decimal;
+    /**
+     * Subtracts a percentage value from the current value of the
+     * decimal. For example a value of 10 represent 10% or a value of
+     * 85 represents 85%.
+     */
+    subtractPercent(value: Decimal): Decimal;
+    /**
+     * Returns a string representation of this object.
+     */
+    toString(): string;
+    /**
+     * The valueOf() method is called by the ECMAScript interpret to return
+     * the "natural" value of an object. The Decimal object returns its
+     * current value as number. With this behavior script snippets can
+     * be written like:
+     * 
+     * `
+     * var d = new Decimal( 10.0 );
+     * var x = 1.0 + d.add( 2.0 );
+     * `
+     * 
+     * where x will be at the end 13.0.
+     */
+    valueOf(): any;
+}
+
+export = Decimal;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/FilteringCollection.d.ts

@@ -0,0 +1,75 @@
+import Collection = require('./Collection');
+import utilMap = require('./Map');
+
+/**
+ * dw.util.FilteringCollection is an extension of
+ * dw.util.Collection which provides possibilities to
+ * 
+ * - filter the elements to return a new
+ * dw.util.FilteringCollection with a filtered set of elements
+ * - sort the elements to return a new
+ * dw.util.FilteringCollection with a defined sort order
+ * - transform the elements to return a new
+ * dw.util.FilteringCollection containing related elements
+ * - provide a map of the elements against a predefined key
+ * 
+ * Usage - In the current version each
+ * dw.util.FilteringCollection provides a set of predefined
+ * qualifier constants which can be passed into the
+ * select method used to filter the elements. Generally
+ * qualifiers have the prefix QUALIFIER_. A second method
+ * sort is used to create a new instance with a different
+ * element ordering, which takes an orderB< constant. Generally
+ * orderBys have the prefix ORDERBY_: examples are
+ * dw.order.ShippingOrder.ORDERBY_ITEMID,
+ * dw.order.ShippingOrder.ORDERBY_ITEMPOSITION, and ORDERBY_REVERSE can
+ * be used to provide a dw.util.FilteringCollection with the reverse
+ * ordering. An example with method dw.order.ShippingOrder.getItems:
+ * 
+ * `
+ * 
+ * var allItems     : FilteringCollection = shippingOrder.items;
+ * 
+ * var productItems : FilteringCollection = allItems.select(ShippingOrder.QUALIFIER_PRODUCTITEMS);
+ * 
+ * var serviceItems : FilteringCollection = allItems.select(ShippingOrder.QUALIFIER_SERVICEITEMS);
+ * 
+ * var byPosition   : FilteringCollection = productItems.sort(ShippingOrder.ORDERBY_ITEMPOSITION);
+ * 
+ * var revByPosition: FilteringCollection = byPosition.sort(FilteringCollection.ORDERBY_REVERSE);
+ * 
+ * var mapByItemID  : Map = allItems.asMap();
+ * `
+ */
+declare class FilteringCollection<T> extends Collection<T> {
+    /**
+     * Pass this orderBy with the sort method to
+     * obtain a new dw.util.FilteringCollection with the reversed sort
+     * order. Only use on a dw.util.FilteringCollection which has been
+     * previously sorted.
+     */
+    static readonly ORDERBY_REVERSE: any;
+    private constructor();
+    /**
+     * Returns a dw.util.Map containing the elements of this
+     * dw.util.FilteringCollection against a predefined key. The key
+     * used is documented in the method returning the
+     * dw.util.FilteringCollection and is typically the ItemID assigned
+     * to an element in the collection.
+     */
+    asMap(): utilMap<any, any>;
+    /**
+     * Select a new dw.util.FilteringCollection instance by passing a
+     * predefined qualifier as an argument to this method. See
+     * dw.util.FilteringCollection.
+     */
+    select(qualifier: any): FilteringCollection<T>;
+    /**
+     * Select a new dw.util.FilteringCollection instance by passing a
+     * predefined orderBy as an argument to this method. See
+     * dw.util.FilteringCollection.
+     */
+    sort(qualifier: any): FilteringCollection<T>;
+}
+
+export = FilteringCollection;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/Geolocation.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Read-only class representing a position on the earth (latitude and longitude)
+ * and information associated with that location (e.g. country, city, etc). The
+ * Commerce Cloud Digital system can provide geolocation information for a Request
+ * and this information can be used in customer group segmentation rules.
+ * 
+ * Note: This class is not related to the store locator API (i.e. the
+ * GetNearestStores pipelet) which uses a static set of store locations loaded
+ * into the system by the merchant.
+ * 
+ * This product includes GeoLite2 data created by MaxMind, available from
+ * http://www.maxmind.com.
+ */
+declare class Geolocation {
+    /**
+     * Returns 'true' if a valid GeoLocation was found for the IP address
+     * (meaning at least Latitude and Longitude were found), false otherwise.
+     */
+    readonly available: boolean;
+    /**
+     * Get the city name in English associated with this location.
+     */
+    readonly city: string;
+    /**
+     * Get the ISO country code associated with this location.
+     */
+    readonly countryCode: string;
+    /**
+     * Get the country name in English that the system associates with this location on the
+     * earth.
+     */
+    readonly countryName: string;
+    /**
+     * Get the latitude coordinate associated with this location which is a
+     * number between -90.0 and +90.0.
+     */
+    readonly latitude: number;
+    /**
+     * Get the longitude coordinate associated with this location which is a
+     * number between -180.0 and +180.0.
+     */
+    readonly longitude: number;
+    /**
+     * Get the metro code associated with this location.
+     */
+    readonly metroCode: string;
+    /**
+     * Get the postal code associated with this location.
+     */
+    readonly postalCode: string;
+    /**
+     * Get the region (e.g. province or state) code for this location.
+     */
+    readonly regionCode: string;
+    /**
+     * Get the region (e.g. province in state) name in English that the system
+     * associates with this location.
+     */
+    readonly regionName: string;
+    /**
+     * Constructor for a Geolocation object
+     */
+    constructor(countryCode: string, countryName: string, regionCode: string, regionName: string, metroCode: string, city: string, postalCode: string, latitude: number, longitude: number);
+    /**
+     * Get the city name in English associated with this location.
+     */
+    getCity(): string;
+    /**
+     * Get the ISO country code associated with this location.
+     */
+    getCountryCode(): string;
+    /**
+     * Get the country name in English that the system associates with this location on the
+     * earth.
+     */
+    getCountryName(): string;
+    /**
+     * Get the latitude coordinate associated with this location which is a
+     * number between -90.0 and +90.0.
+     */
+    getLatitude(): number;
+    /**
+     * Get the longitude coordinate associated with this location which is a
+     * number between -180.0 and +180.0.
+     */
+    getLongitude(): number;
+    /**
+     * Get the metro code associated with this location.
+     */
+    getMetroCode(): string;
+    /**
+     * Get the postal code associated with this location.
+     */
+    getPostalCode(): string;
+    /**
+     * Get the region (e.g. province or state) code for this location.
+     */
+    getRegionCode(): string;
+    /**
+     * Get the region (e.g. province in state) name in English that the system
+     * associates with this location.
+     */
+    getRegionName(): string;
+    /**
+     * Returns 'true' if a valid GeoLocation was found for the IP address
+     * (meaning at least Latitude and Longitude were found), false otherwise.
+     */
+    isAvailable(): boolean;
+}
+
+export = Geolocation;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/HashMap.d.ts

@@ -0,0 +1,17 @@
+import utilMap = require('./Map');
+
+/**
+ * Represents a hash map of objects.
+ */
+declare class HashMap<K, V> extends utilMap<K, V> {
+    /**
+     * Constructs a new HashMap.
+     */
+    constructor();
+    /**
+     * Returns a shallow copy of this map.
+     */
+    clone(): HashMap<any, any>;
+}
+
+export = HashMap;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/HashSet.d.ts

@@ -0,0 +1,24 @@
+import utilSet = require('./Set');
+import Collection = require('./Collection');
+
+/**
+ * Represents a HashSet
+ */
+declare class HashSet<T> extends utilSet<T> {
+    /**
+     * Constructs a new HashMap.
+     */
+    constructor();
+    /**
+     * Construct a new HashSet by
+     * initializing the HashSet with the elements of the
+     * given collection.
+     */
+    constructor(collection: Collection<T>);
+    /**
+     * Returns a shallow copy of this set.
+     */
+    clone(): HashSet<any>;
+}
+
+export = HashSet;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/Iterator.d.ts

@@ -0,0 +1,34 @@
+import List = require('./List');
+
+/**
+ * The Iterator class allows you to access items in a collection.
+ */
+declare class Iterator<T> {
+    /**
+     * Convert the iterator into a list. After this conversion the
+     * iterator is empty and hasNext() will always return false.
+     * 
+     * Note: This method should be used with care. For example a large database
+     * result is pulled into memory completely with this method and can cause
+     * an OutOfMemory situation.
+     */
+    asList(): List<any>;
+    /**
+     * Converts a sub-sequence within the iterator into a list.
+     * 
+     * Note: This method should be used with care. For example a large database
+     * result is pulled into memory completely with this method and can cause
+     * an OutOfMemory situation.
+     */
+    asList(start: number, size: number): List<any>;
+    /**
+     * Indicates if there are more elements.
+     */
+    hasNext(): boolean;
+    /**
+     * Returns the next element from the Iterator.
+     */
+    next(): T;
+}
+
+export = Iterator;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/LinkedHashMap.d.ts

@@ -0,0 +1,18 @@
+import utilMap = require('./Map');
+
+/**
+ * This class implements a HashMap, which guarantees a iteration order
+ * according the put-order of the elements in the map.
+ */
+declare class LinkedHashMap<K, V> extends utilMap<K, V> {
+    /**
+     * Constructs a new LinkedHashMap.
+     */
+    constructor();
+    /**
+     * Returns a shallow copy of this map.
+     */
+    clone(): LinkedHashMap<any, any>;
+}
+
+export = LinkedHashMap;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/LinkedHashSet.d.ts

@@ -0,0 +1,26 @@
+import utilSet = require('./Set');
+import Collection = require('./Collection');
+
+/**
+ * The class LinkedHashSet implements a hash set with a guaranteed iteration
+ * order. The elements are iterated in the order they have been added to the
+ * HashSet.
+ */
+declare class LinkedHashSet<T> extends utilSet<T> {
+    /**
+     * Constructs a new LinkHashSet.
+     */
+    constructor();
+    /**
+     * Constructor for a new LinkedHashSet. The constructor
+     * initializes the LinkedHashSet with the elements of the
+     * given collection.
+     */
+    constructor(collection: Collection<T>);
+    /**
+     * Returns a shallow copy of this set.
+     */
+    clone(): LinkedHashSet<any>;
+}
+
+export = LinkedHashSet;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/util/List.d.ts

@@ -0,0 +1,148 @@
+import Collection = require('./Collection');
+
+/**
+ * An ordered collection of objects. The user of a List has precise control over
+ * where in the list each element is inserted. The user can access elements by
+ * their integer index (position in the list), and search for elements in the
+ * list. Lists are zero based similar to arrays. Unlike sets, lists allow
+ * duplicate elements.
+ */
+declare class List<T> extends Collection<T> {
+    /**
+     * Convenience variable, for an empty and immutable list.
+     */
+    static EMPTY_LIST: List<any>;
+    /**
+     * Adds the specified object into the list at the specified index.
+     */
+    addAt(index: number, value: T): void;
+    /**
+     * Creates and returns a new List that is the result of concatenating this
+     * list with each of the specified values. This list itself is unmodified.
+     * If any of the specified values is itself an array or a Collection, then
+     * the elements of that Collection or array are appended to the new list
+     * rather than the object itself.
+     */
+    concat(...values: T[]): List<T>;
+    /**
+     * Replaces all of the elements in the list with the given object.
+     */
+    fill(obj: T): void;
+    /**
+     * Returns the object at the specified index.
+     */
+    get(index: number): T;
+    /**
+     * Returns the index of the first occurrence of the specified element in
+     * this list, or -1 if this list does not contain the element.
+     */
+    indexOf(value: T): number;
+    /**
+     * Converts all elements of the list to a string by calling the toString()
+     * method and then concatenates them together, with a comma between
+     * elements.
+     */
+    join(): string;
+    /**
+     * Converts all elements of the list to a string by calling the toString()
+     * method and then concatenates them together, with the separator string
+     * between elements. If null is passed, then the comma character is used as
+     * a separator.
+     */
+    join(separator: string | null): string;
+    /**
+     * Returns the index of the last occurrence of the specified element in this
+     * list, or -1 if this list does not contain the element.
+     */
+    lastIndexOf(value: T): number;
+    /**
+     * Removes and returns the last element from the list.
+     */
+    pop(): T;
+    /**
+     * Appends the specified values to the end of the list in order.
+     */
+    push(...values: T[]): number;
+    /**
+     * Removes the object at the specified index.
+     */
+    removeAt(index: number): T;
+    /**
+     * Replaces all occurrences of oldValue with newValue.
+     */
+    replaceAll(oldValue: any, newValue: any): boolean;
+    /**
+     * Reverses the order of the elements in the list.
+     */
+    reverse(): void;
+    /**
+     * Rotates the elements in the list by the specified distance.
+     */
+    rotate(distance: number): void;
+    /**
+     * Replaces the object at the specified index in this list with the specified object.
+     */
+    set(index: number, value: T): T;
+    /**
+     * Removes and returns the first element of the list. If the list is already
+     * empty, this method simply returns null.
+     */
+    shift(): T;
+    /**
+     * Randomly permutes the elements in the list.
+     */
+    shuffle(): void;
+    /**
+     * Returns the size of this list.
+     */
+    size(): number;
+    /**
+     * Returns a slice, or sublist, of this list. The returned list contains the
+     * element specified by `from` and all subsequent elements up to
+     * the end of this list.
+     */
+    slice(from: number): List<T>;
+    /**
+     * Returns a slice, or sublist, of this list. The returned list contains the
+     * element specified by `from` and all subsequent elements up to,
+     * but not including, the element specified by `to`.
+     */
+    slice(from: number, to: number): List<T>;
+    /**
+     * Sorts the elements of the list based on their natural
+     * order.
+     * 
+     * This sort is guaranteed to be stable:  equal elements will
+     * not be reordered as a result of the sort.
+     */
+    sort(): void;
+    /**
+     * Sorts the elements of a list. The order of the elements is
+     * determined with a comparator (see PropertyComparator) or with the help
+     * of the given function. The function must take two parameters and return
+     * a value <0 if the first parameter is smaller than the second, a value
+     * of 0 if both are equal and a value if >0 if the first one is greater
+     * than the second parameter.
+     * 
+     * This sort is guaranteed to be stable:  equal elements will
+     * not be reordered as a result of the sort.
+     */
+    sort(comparator: Object): void;
+    /**
+     * Returns a list containing the elements in this list identified
+     * by the specified arguments.
+     */
+    subList(from: number, to: number): List<T>;
+    /**
+     * Swaps the elements at the specified positions in the list.
+     */
+    swap(i: number, j: number): void;
+    /**
+     * Inserts values at the beginning of the list.  The first argument
+     * becomes the new element 0;  the second argument becomes element 1;
+     * and so on.
+     */
+    unshift(...values: any[]): number;
+}
+
+export = List;