@salesforce/b2c-cli 1.10.0 → 1.12.0

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/Transaction.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Represents the current transaction. A transaction provides a context for performing atomic changes to persistent
+ * business objects. Before a business object can be created, changed, or deleted, a transaction must be started using
+ * the begin method. All changes on the touched business objects will only be made durable when the
+ * transaction is committed with commit. If a transaction is rolled back, all changes so far will be reverted
+ * and the business object will have their previous state again. It is possible to begin a transaction multiple times in
+ * a nested way (like begin-begin-commit-commit). In this case, in order to commit the changes the commit method must be
+ * called symmetrically as often as begin. It is also possible to run multiple transactions within a single request, one
+ * after another (like begin-commit-begin-commit). In case of any exception while working with business objects inside
+ * of a transaction, the transaction cannot be committed anymore, but only be rolled back. Business code may try to take
+ * appropriate actions if it expects business-related problems at commit (for example, constraint violations). When a
+ * transaction is still open at the end of a pipeline call, controller call, or job step, the remaining changes are
+ * committed unless an exception is thrown.
+ * 
+ * The following best practices exist for using transactions:
+ * 
+ * - Avoid long running transactions in jobs.
+ * - Use one transaction for changes that belong together and need a joint rollback. In most cases, one transaction
+ * for all changes in a request is better than multiple transactions for each individual object.
+ * - Don’t begin and commit a huge number of small transactions in a loop.
+ * - Avoid changing the same objects in parallel transactions.
+ * 
+ * Example 1 - explicit control:
+ * 
+ * ```
+ * var txn = require('dw/system/Transaction');
+ * txn.begin();
+ * // work with business objects here
+ * txn.commit();
+ * ```
+ * 
+ * Example 2 - implicit control:
+ * @example
+ * var txn = require('dw/system/Transaction');
+ * txn.wrap(function(){
+ * // work with business objects here
+ * });
+ */
+declare class Transaction {
+    private constructor();
+    /**
+     * Begins a transaction.
+     */
+    static begin(): void;
+    /**
+     * Commits the current transaction. The transaction must have been started with begin before.
+     */
+    static commit(): void;
+    /**
+     * Rolls back the current transaction. The transaction must have been started with begin before.
+     */
+    static rollback(): void;
+    /**
+     * Encloses the provided callback function in a begin-commit transactional context. If the transaction cannot be
+     * committed successfully, it is rolled back instead and an exception is thrown.
+     */
+    static wrap<T>(callback: () => T): T;
+}
+
+export = Transaction;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/index.d.ts

@@ -0,0 +1,57 @@
+import AgentUserStatusCodes = require('./AgentUserStatusCodes');
+import Cache = require('./Cache');
+import CacheMgr = require('./CacheMgr');
+import HookMgr = require('./HookMgr');
+import InternalObject = require('./InternalObject');
+import JobProcessMonitor = require('./JobProcessMonitor');
+import Log = require('./Log');
+import LogNDC = require('./LogNDC');
+import Logger = require('./Logger');
+import OrganizationPreferences = require('./OrganizationPreferences');
+import Pipeline = require('./Pipeline');
+import PipelineDictionary = require('./PipelineDictionary');
+import RESTErrorResponse = require('./RESTErrorResponse');
+import RESTResponseMgr = require('./RESTResponseMgr');
+import RESTSuccessResponse = require('./RESTSuccessResponse');
+import RemoteInclude = require('./RemoteInclude');
+import Request = require('./Request');
+import RequestHooks = require('./RequestHooks');
+import Response = require('./Response');
+import SearchStatus = require('./SearchStatus');
+import Session = require('./Session');
+import Site = require('./Site');
+import SitePreferences = require('./SitePreferences');
+import Status = require('./Status');
+import StatusItem = require('./StatusItem');
+import System = require('./System');
+import Transaction = require('./Transaction');
+
+export {
+    AgentUserStatusCodes,
+    Cache,
+    CacheMgr,
+    HookMgr,
+    InternalObject,
+    JobProcessMonitor,
+    Log,
+    LogNDC,
+    Logger,
+    OrganizationPreferences,
+    Pipeline,
+    PipelineDictionary,
+    RESTErrorResponse,
+    RESTResponseMgr,
+    RESTSuccessResponse,
+    RemoteInclude,
+    Request,
+    RequestHooks,
+    Response,
+    SearchStatus,
+    Session,
+    Site,
+    SitePreferences,
+    Status,
+    StatusItem,
+    System,
+    Transaction
+};

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/template/ISML.d.ts

@@ -0,0 +1,32 @@
+/**
+ * This class provides support for rendering ISML templates. For more details about the ISML syntax, refer to the
+ * Commerce Cloud Digital developer documentation. Templates are stored as *.isml files. They are located in a
+ * locale-specific folder under the '/cartridge/templates' folder, with '/cartridge/template/default' being the default
+ * locale. The template name arguments of the various render methods represent the template path (without file ending)
+ * within this folder structure.
+ * 
+ * Example for rendering a template with arguments from JavaScript code:
+ * 
+ * ```
+ * let isml = require('dw/template/ISML');
+ * isml.renderTemplate('helloworld', {
+ * Message: 'Hello, World!'
+ * });
+ * ```
+ * 
+ * Example code for accessing the template arguments in the 'helloworld.isml' template from the above code snippet:
+ * @example
+ * The message is: <isprint value="${pdict.Message}" />
+ */
+declare class ISML {
+    private constructor();
+    /**
+     * Renders an ISML template and writes the output to the current response. The template may contain ISML tags which
+     * control the character encoding, content type, caching behavior and so on of the response (see ISML
+     * documentation). This method takes an additional JavaScript object as argument. Its properties are accessible for
+     * script expressions in the template under the "pdict.*" variable.
+     */
+    static renderTemplate(template: string, templateArgs: any): void;
+}
+
+export = ISML;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/template/Velocity.d.ts

@@ -0,0 +1,71 @@
+import Writer = require('../io/Writer');
+import File = require('../io/File');
+
+/**
+ * This class renders an Apache Velocity template. For Velocity template syntax, see
+ * Velocity 1.7.
+ * 
+ * The render() methods identify the template to render from:
+ * 
+ * - a template file name, which is resolved in the Dynamic WebDAV file location for the current site.
+ * Template file names must end with either '.vm' or '.vs'.
+ * - a dw.io.File object, which can point to any file system location that is accessible from a script
+ * - a string that holds the template content directly
+ * Note: Files included from an ISML template (either via `#parse` or `#include`) are always resolved
+ * in the Dynamic location, and it is not possible to provide an absolute path.
+ * 
+ * On the target side of rendering, by default the render() methods write to the current response writer. When needed,
+ * a `dw.io.Writer` can be supplied as a target.
+ * 
+ * Parameters for rendering can be passed as a single object holding the parameters as properties.
+ * 
+ * To create a URL, pass the `URLUtils` class.
+ * 
+ * To access localized strings, pass the `Resource` class:
+ * 
+ * ```
+ * `
+ * var urlUtil = require('dw/web/URLUtils');
+ * velocity.render("$url.abs('Foo-Bar','cgid',$res.msg('key')", {'url' : urlUtil, 'res' : dw.web.Resource});
+ * `
+ * ```
+ * 
+ * The complete set of VelocityTools
+ * are provided to the template. You can use the tools to escape dynamic data, format text, and for other common tasks.
+ * 
+ * Template files are cached for different amounts of time, depending on the instance type.
+ */
+declare class Velocity {
+    private constructor();
+    /**
+     * Includes the rendered content of the specified action URL, which usually is a pipeline or controller. Must only be used inside a Velocity
+     * template, such as `$velocity.remoteInclude('Product-Show','sku','42')`
+     */
+    static remoteInclude(action: string, ...namesAndParams: string[]): string;
+    /**
+     * Renders an inline template to the response writer.
+     */
+    static render(templateContent: string, args: Object): void;
+    /**
+     * Renders an inline template to the provided writer.
+     */
+    static render(templateContent: string, args: Object, writer: Writer): void;
+    /**
+     * Renders a template file to the response writer.
+     */
+    static renderTemplate(templateFileName: string, args: Object): void;
+    /**
+     * Renders a template file to the provided writer.
+     */
+    static renderTemplate(templateFileName: string, args: Object, writer: Writer): void;
+    /**
+     * Renders a template file to the response writer.
+     */
+    static renderTemplate(templateFile: File, args: Object): void;
+    /**
+     * Renders a template file to the provided writer.
+     */
+    static renderTemplate(templateFile: File, args: Object, writer: Writer): void;
+}
+
+export = Velocity;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/template/index.d.ts

@@ -0,0 +1,7 @@
+import ISML = require('./ISML');
+import Velocity = require('./Velocity');
+
+export {
+    ISML,
+    Velocity
+};

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

@@ -0,0 +1,40 @@
+import List = require('./List');
+import Collection = require('./Collection');
+import utilIterator = require('./Iterator');
+
+/**
+ * The ArrayList class is a container for a list of objects.
+ */
+declare class ArrayList<T> extends List<T> {
+    /**
+     * Constructor for a new ArrayList.
+     */
+    constructor();
+    /**
+     * Constructor for a new ArrayList. The constructor initializes the
+     * ArrayList with the elements of the given collection.
+     */
+    constructor(collection: Collection<T>);
+    /**
+     * Constructor for a new ArrayList. The constructor initializes the
+     * ArrayList with the elements of the given iterator.
+     */
+    constructor(iterator: utilIterator<any>);
+    /**
+     * Constructor for a new ArrayList. The constructor initializes the
+     * ArrayList with the arguments given as constructor parameters. The method
+     * can also be called with an ECMA array as argument.
+     * 
+     * If called with a single ECMA array as argument the individual elements of
+     * that array are used to initialize the ArrayList. To create an ArrayList
+     * with a single array as element, create an empty ArrayList and then call
+     * the method add1() on it.
+     */
+    constructor(...values: any[]);
+    /**
+     * Returns a shallow copy of this array list.
+     */
+    clone(): ArrayList<any>;
+}
+
+export = ArrayList;

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

@@ -0,0 +1,159 @@
+/**
+ * The Assert class provides utility methods for assertion events.
+ */
+declare class Assert {
+    private constructor();
+    /**
+     * Propagates an assertion
+     * if the specified objects are not equal.
+     */
+    static areEqual(arg1: any, arg2: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified objects are not equal.
+     */
+    static areEqual(arg1: any, arg2: any, msg: string): void;
+    /**
+     * Propagates an assertion
+     * if the specified objects are equal.
+     */
+    static areNotEqual(arg1: any, arg2: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified objects are equal.
+     */
+    static areNotEqual(arg1: any, arg2: any, msg: string): void;
+    /**
+     * Propagates an assertion
+     * if the specified objects are not the same.
+     */
+    static areSame(arg1: any, arg2: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified objects are not the same.
+     */
+    static areSame(arg1: any, arg2: any, msg: string): void;
+    /**
+     * Propagates a failure assertion.
+     */
+    static fail(): void;
+    /**
+     * Propagates a failure assertion using the
+     * specified message.
+     */
+    static fail(msg: string): void;
+    /**
+     * Propagates an assertion
+     * if the specified check does not evaluate to
+     * an empty object.
+     */
+    static isEmpty(arg: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified check does not evaluate to
+     * an empty object.
+     */
+    static isEmpty(arg: any, msg: string): void;
+    /**
+     * Propagates an assertion if the
+     * specified check does not evaluate to false.
+     */
+    static isFalse(check: boolean): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified check does not evaluate to false.
+     */
+    static isFalse(check: boolean, msg: string): void;
+    /**
+     * Propagates an assertion if the specified object 'arg' is not an instance
+     * of the specified class 'clazz'.
+     * 
+     * For example, the following call does not propagate an assertion:
+     * 
+     * ```
+     * `
+     * var test = new dw.util.HashMap();
+     * dw.util.Assert.isInstanceOf(dw.util.HashMap, test);
+     * `
+     * ```
+     * 
+     * But the following call will propagate an assertion:
+     * 
+     * ```
+     * `
+     * var test = new dw.util.Set();
+     * dw.util.Assert.isInstanceOf(dw.util.HashMap, test);
+     * `
+     * ```
+     * 
+     * Note that 'clazz' can only be a Demandware API Scripting class.
+     */
+    static isInstanceOf(clazz: any, arg: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified object is not an instance of the specified class.
+     * 
+     * For example, the following call does not propagate an assertion:
+     * 
+     * ```
+     * `
+     * var test = new dw.util.HashMap();
+     * dw.util.Assert.isInstanceOf(dw.util.HashMap, test);
+     * `
+     * ```
+     * 
+     * But the following call will propagate an assertion:
+     * 
+     * ```
+     * `
+     * var test = new dw.util.Set();
+     * dw.util.Assert.isInstanceOf(dw.util.HashMap, test);
+     * `
+     * ```
+     * 
+     * Note that 'clazz' can only be a Demandware API Scripting class.
+     */
+    static isInstanceOf(clazz: any, arg: any, msg: string): void;
+    /**
+     * Propagates an assertion
+     * if the specified object is empty.
+     */
+    static isNotEmpty(arg: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified object is empty.
+     */
+    static isNotEmpty(arg: any, msg: string): void;
+    /**
+     * Propagates an assertion if the
+     * specified object is null.
+     */
+    static isNotNull(arg: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified object is null.
+     */
+    static isNotNull(arg: any, msg: string): void;
+    /**
+     * Propagates an assertion
+     * if the specified object is not null.
+     */
+    static isNull(arg: any): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified object is not null.
+     */
+    static isNull(arg: any, msg: string): void;
+    /**
+     * Propagates an assertion if the
+     * specified check does not evaluate to true.
+     */
+    static isTrue(check: boolean): void;
+    /**
+     * Propagates an assertion using the specified message
+     * if the specified check does not evaluate to true.
+     */
+    static isTrue(check: boolean, msg: string): void;
+}
+
+export = Assert;

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

@@ -0,0 +1,104 @@
+/**
+ * The BigInteger class is a helper class to represent an arbitrary long integer number.
+ * The Demandware framework doesn't use this class, but in some special cases
+ * web services that declare an XML element with "xsd:integer", which is by definition
+ * an arbitrary long integer number, require the use of this class.
+ * 
+ * The class is designed in a way that it can be used very similar to a
+ * desktop calculator. For example:
+ * 
+ * ```
+ * var i = new BigInteger( 10 );
+ * var result = d.add( 2 ).sub( 3 ).get();
+ * ```
+ * 
+ * The above code will return 9 as result.
+ * @deprecated Replaced by TopLevel.BigInt.
+ */
+declare class BigInteger {
+    /**
+     * Constructs a new BigInteger with the value 0.
+     */
+    constructor();
+    /**
+     * Constructs a new BigInteger using the specified Number value.
+     */
+    constructor(value: number);
+    /**
+     * Constructs a new BigInteger using the specified string representation of
+     * a number.
+     */
+    constructor(value: string);
+    /**
+     * Returns a new BigInteger with the absolute value of this BigInteger.
+     */
+    abs(): BigInteger;
+    /**
+     * Adds a Number value to this BigInteger and returns the new BigInteger.
+     */
+    add(value: number): BigInteger;
+    /**
+     * Adds an BigInteger value to this BigInteger and returns the new BigInteger.
+     */
+    add(value: BigInteger): BigInteger;
+    /**
+     * Divides this BigInteger by the specified BigInteger and returns the new BigInteger.
+     */
+    divide(value: number): BigInteger;
+    /**
+     * Divides this BigInteger by the specified BigInteger and returns the new BigInteger.
+     */
+    divide(value: BigInteger): BigInteger;
+    /**
+     * Compares two BigInteger values whether they are equivalent.
+     */
+    equals(other: any): boolean;
+    /**
+     * Returns the value of the BigInteger as a Number.
+     */
+    get(): number;
+    /**
+     * Calculates the hash code for this BigInteger;
+     */
+    hashCode(): number;
+    /**
+     * Multiples the specified Number value with this BigInteger and returns the new BigInteger.
+     */
+    multiply(value: number): BigInteger;
+    /**
+     * Multiples the specified BigInteger value with this BigInteger and returns the new BigInteger.
+     */
+    multiply(value: BigInteger): BigInteger;
+    /**
+     * Returns a new BigInteger with the negated value of this BigInteger.
+     */
+    negate(): BigInteger;
+    /**
+     * Subtracts the specified Number value from this BigInteger and returns the new BigInteger.
+     */
+    subtract(value: number): BigInteger;
+    /**
+     * Subtracts the specified BigInteger value from this BigInteger and returns the new BigInteger.
+     */
+    subtract(value: BigInteger): BigInteger;
+    /**
+     * 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 BigInteger object returns its
+     * current value as number. With this behavior script snippets can
+     * be written like:
+     * 
+     * ```
+     * var i = new BigInteger( 10 );
+     * var x = 1 + d.add( 2 );
+     * ```
+     * 
+     * where x will be at the end 13.
+     */
+    valueOf(): any;
+}
+
+export = BigInteger;

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

@@ -0,0 +1,99 @@
+/**
+ * A simple immutable class representing an array of bytes, used for working
+ * with binary data in a scripting context.
+ * 
+ * It acts as a view to TopLevel.ArrayBuffer. The buffer can be accessed through asUint8Array.
+ * 
+ * Limitation:
+ * The size of the resulting byte representation is limited by the quota api.jsArrayBufferSize that is defining the max size for a TopLevel.ArrayBuffer.
+ */
+declare class Bytes {
+    /**
+     * The maximum number of bytes that a Bytes object can represent == 10KB
+     * @deprecated No longer used by the Bytes class.
+     */
+    static readonly MAX_BYTES = 10240;
+    /**
+     * Returns the number of bytes represented by this object.
+     */
+    readonly length: number;
+    /**
+     * Construct a Bytes object from the given TopLevel.ArrayBuffer or view. The bytes object also acts as a
+     * view on the underlying TopLevel.ArrayBuffer. If a view is given that makes only a part of the storage
+     * array visible then this Bytes object will also make only the same part visible. The storage data is not copied.
+     * @since 21.2
+     */
+    constructor(arrayBufferOrView: any);
+    /**
+     * Construct a Bytes object from the given string using the default
+     * encoding. Convenience for Bytes( string, "UTF-8" ).
+     * @throws IllegalArgumentException If the encoded byte sequence exceeds the maximum number of bytes.
+     */
+    constructor(string: string);
+    /**
+     * Construct a Bytes object from the given string using the given encoding.
+     * This method always replaces malformed input and unmappable character
+     * sequences with encoding defaults.
+     * @throws IllegalArgumentException If the named encoding is not supported or if the encoded byte sequence exceeds the maximum number of bytes.
+     */
+    constructor(string: string, encoding: string | null);
+    /**
+     * Returns a TopLevel.Uint8Array based on the TopLevel.ArrayBuffer used for this Bytes object.
+     * Changes to the returned TopLevel.ArrayBuffer will be visible in the Bytes object.
+     * @since 21.2
+     */
+    asUint8Array(): Object;
+    /**
+     * Returns the value of the byte at position index as an integer. If index
+     * is out of range an exception is thrown. The byte is interpreted as signed
+     * and so the value returned will always be between -128 and +127.
+     * @throws IndexOutOfBoundsException If the index argument is negative or not less than the length of this byte array.
+     */
+    byteAt(index: number): number;
+    /**
+     * Return a new Bytes object containing the subsequence of this object's bytes specified by the index and length
+     * parameters. The returned object is a new view onto the same data, no data is copied.
+     * @throws ArrayIndexOutOfBoundsException If index  <  0 or index  >  getLength() or index + length  > getLength()
+     * @throws IllegalArgumentException If length  <  0
+     */
+    bytesAt(index: number, length: number): Bytes;
+    /**
+     * Returns the number of bytes represented by this object.
+     */
+    getLength(): number;
+    /**
+     * Absolute get method for reading a signed integer value (32 bit) in
+     * network byte order(= big endian).
+     * @throws IndexOutOfBoundsException If index is negative or not smaller than the number of bytes minus three.
+     */
+    intAt(index: number): number;
+    /**
+     * Return a new Bytes object which has the same bytes as this one in reverse
+     * order.
+     */
+    reverse(): Bytes;
+    /**
+     * Absolute get method for reading a signed short value (16 bit) in network
+     * byte order(= big endian).
+     * @throws IndexOutOfBoundsException If index is negative or not smaller than the number of bytes minus one.
+     */
+    shortAt(index: number): number;
+    /**
+     * Constructs a new String by decoding this array of bytes using the
+     * default encoding. Convenience for toString( "UTF-8" ).
+     * Limitation:
+     * The method is protected by the quota api.jsStringLength that prevents creation of too long strings.
+     */
+    toString(): string;
+    toString(): string;
+    /**
+     * Constructs a new String by decoding this array of bytes using the
+     * specified encoding.
+     * Limitation:
+     * The method is protected by the quota api.jsStringLength that prevents creation of too long strings.
+     * @throws IllegalArgumentException If the named encoding is not supported.
+     */
+    toString(encoding: string): string;
+}
+
+export = Bytes;