@talxis/base-controls 1.2406.2 → 1.2406.4

package/src/components/Lookup/lib.ts

@@ -1,3110 +0,0 @@
-//@ts-nocheck
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Jim Daly
-
-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.
-*/
-
-export namespace Sdk.FetchXml {
-    @sealed
-    export class attribute {
-        /**
-         * Contains the data for a fetchXml attribute element.
-         * @param name The logical name of the attribute
-         */
-        constructor(name: string) {
-            //new keyword not required
-            if (!(this instanceof attribute))
-            { return new attribute(name); }
-
-            this.name = name;
-        }
-
-        private _name: string;
-        private _build: Build = null;
-        private _addedBy: string = null;
-        private _alias: string = null;
-        private _aggregate: Aggregate = null;
-        private _groupBy: boolean = null;
-        private _dateGrouping: DateGrouping = null;
-        private _userTimeZone: boolean = null;
-
-        /**
-        *Gets or sets logical name of the attribute
-        */
-        public get name(): string {
-            return this._name;
-        }
-        public set name(value: string) {
-            if (!Util.isString(value)) {
-                throw new Error("Sdk.FetchXml.attribute name property must be an string.");
-            }
-            this._name = value;
-        }
-        /**
-        *Gets or sets the build of the attribute
-        */
-        public get build(): Build {
-            return this._build;
-        }
-        public set build(value: Build) {
-            if (!Util.isEnumMemberOrNull(Build, value)) {
-                throw new Error("Sdk.FetchXml.attribute build property must be an Sdk.FetchXml.Build value or null.");
-            }
-            this._build = value;
-        }
-        /**
-        *Gets or sets the addedBy property of the attribute
-        */
-        public get addedBy(): string {
-            return this._addedBy;
-        }
-        public set addedBy(value: string) {
-            if (!Util.isStringOrNull(value)) {
-                throw new Error("Sdk.FetchXml.attribute addedBy property must be an string value or null.");
-            }
-            this._addedBy = value;
-        }
-        /**
-        *Gets or sets the alias property of the attribute
-        */
-        public get alias(): string {
-            return this._alias;
-        }
-        public set alias(value: string) {
-            if (!Util.isStringOrNull(value)) {
-                throw new Error("Sdk.FetchXml.attribute alias property must be an string value or null.");
-            }
-            this._alias = value;
-        }
-        /**
-        *Gets or sets the aggregate property of the attribute
-        */
-        public get aggregate(): Aggregate {
-            return this._aggregate;
-        }
-        public set aggregate(value: Aggregate) {
-            if (!Util.isEnumMemberOrNull(Aggregate, value)) {
-                throw new Error("Sdk.FetchXml.attribute aggregate property must be an Sdk.FetchXml.Aggregate value or null.");
-            }
-            this._aggregate = value;
-        }
-        /**
-        *Gets or sets the groupBy property of the attribute
-        */
-        public get groupBy(): boolean {
-            return this._groupBy;
-        }
-        public set groupBy(value: boolean) {
-            if (!Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.attribute groupBy property must be an boolean value or null.");
-            }
-            this._groupBy = value;
-        }
-        /**
-        *   Gets or sets the dateGrouping property of the attribute
-        */
-        public get dateGrouping(): DateGrouping {
-            return this._dateGrouping;
-        }
-        public set dateGrouping(value: DateGrouping) {
-            if (!Util.isEnumMemberOrNull(DateGrouping, value)) {
-                throw new Error("Sdk.FetchXml.attribute dateGrouping property must be an Sdk.FetchXml.DateGrouping value or null.");
-            }
-            this._dateGrouping = value;
-        }
-        /**
-        *Gets or sets the userTimeZone property of the attribute
-        */
-        public get userTimeZone(): boolean {
-            return this._userTimeZone;
-        }
-        public set userTimeZone(value: boolean) {
-            if (!Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.attribute userTimeZone property must be an boolean value or null.");
-            }
-            this._userTimeZone = value;
-        }
-
-        /** @description Sets the name property of the attribute attribute
-        * @param {string} name The name value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-        public setName(name: string) {
-            this.name = name;
-            return this;
-        }
-
-        /** @description Sets the build property of the build attribute
-        * @param {Sdk.FetchXml.Build | null} build The build value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-        public setBuild(build?: Build) {
-            (build) ? this.build = build : this.build = null;
-            return this;
-        }
-
-        /** @description Sets the addedBy property of the attribute attribute
-        * @param {string | null} addedBy The addedBy value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-        public setAddedBy(addedBy?: string) {
-            (addedBy) ? this.addedBy = addedBy : this.addedBy = null;
-            return this;
-        }
-
-        /** @description Sets the alias property of the attribute attribute
-        * @param {string} alias The alias value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-        public setAlias(alias?: string) {
-            (alias) ? this.alias = alias : this.alias = null;
-            return this;
-        }
-
-        /** @description Sets the aggregate property of the attribute attribute
-        * @param {Sdk.FetchXml.Aggregate | null } aggregate The aggregate value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-
-        public setAggregate(aggregate?: Aggregate) {
-            (aggregate) ? this.aggregate = aggregate : this.aggregate = null;
-            return this;
-        }
-        /** @description Sets the groupBy property of the attribute attribute
-        * @param {boolean | null} groupBy The groupBy value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-
-        public setGroupBy(groupBy?: boolean) {
-            (groupBy) ? this.groupBy = groupBy : groupBy = null;
-            return this;
-        }
-
-        /** @description Sets the dateGrouping property of the attribute attribute
-        * @param {Sdk.FetchXml.DateGrouping | null} dateGrouping The dateGrouping value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-        public setDateGrouping(dateGrouping?: DateGrouping) {
-            (dateGrouping) ? this.dateGrouping = dateGrouping : this.dateGrouping = null;
-            return this;
-        }
-
-        /** @description Sets the userTimeZone property of the attribute attribute
-        * @param {boolean | null} userTimeZone The userTimeZone value to apply to the attribute
-        * @returns {Sdk.FetchXml.attribute}
-        */
-        public setUserTimeZone(userTimeZone?: boolean) {
-            (userTimeZone) ? this.userTimeZone = userTimeZone : this.userTimeZone = null;
-            return this;
-        }
-
-        //Internal use only
-        toXml(doc: XMLDocument): Node {
-            var aNode = doc.createElement("attribute");
-            aNode.setAttribute("name", <string>this.name);
-            if (this.build) {
-                aNode.setAttribute("build", <string>this.build);
-            }
-            if (this.addedBy) {
-                aNode.setAttribute("addedby", <string>this.addedBy);
-            }
-            if (this.alias) {
-                aNode.setAttribute("alias", <string>this.alias);
-            }
-            if (this.aggregate) {
-                aNode.setAttribute("aggregate", <string>this.aggregate);
-            }
-            if (Util.isBoolean(this.groupBy)) {
-                aNode.setAttribute("groupby", (this.groupBy) ? "true" : "false");
-            }
-            if (this.dateGrouping) {
-                aNode.setAttribute("dategrouping", <string>this.dateGrouping);
-            }
-            if (Util.isBoolean(this.userTimeZone)) {
-                aNode.setAttribute("usertimezone", (this.userTimeZone) ? "true" : "false");
-            }
-            return aNode;
-        }
-
-        //Internal use only
-        static attributeFromXml(xml) {
-            var attObj = new attribute(xml.attributes.getNamedItem("name").nodeValue);
-
-            Util.parseAttributes(xml, attObj, (attObj, name, value) => {
-                switch (name) {
-                    case "build":
-                    case "alias":
-                    case "aggregate":
-                        attObj[name] = value;
-                        break;
-                    case "addedby":
-                        attObj.addedBy = value;
-                        break;
-                    case "dategrouping":
-                        attObj.dateGrouping = value;
-                        break;
-                    case "groupby":
-                        attObj.groupBy = Util.convertFetchBoolType(value);
-                    case "usertimezone":
-                        attObj.userTimeZone = Util.convertFetchBoolType(value);
-                        break;
-                    default:
-                        break;
-
-                }
-            });
-
-            return attObj;
-        }
-    }
-    @sealed
-    export class condition {
-        /**
-         * Contains the data for a fetchXml condition element.
-         * @param attribute The attribute to evaluate in the condition
-         * @param operator The operator to use when evaluating the attribute
-         * @param [values] The value(s) to apply in the comparison.
-         */
-        constructor(attribute: string, operator: Sdk.FetchXml.Operator, values?: Array<Sdk.FetchXml.value>) {
-            //New keyword not required in JS
-            if (!(this instanceof Sdk.FetchXml.condition))
-            { return new Sdk.FetchXml.condition(attribute, operator, values); }
-
-            if (attribute && operator) {
-                this.attribute = attribute;
-                this.operator = operator;
-            }
-            else {
-                throw new Error("Sdk.FetchXml.condition constructor parameters attribute and operator are required.");
-            }
-            if (values)
-                this.values = values;
-        }
-
-        private _aggregate: Sdk.FetchXml.Aggregate = null;
-        private _alias: string = null;
-        private _attribute: string = null;
-        private _column: string = null;
-        private _entityname: string = null;
-        private _operator: Sdk.FetchXml.Operator = null;
-        private _rowAggregate: Sdk.FetchXml.RowAggregate = null;
-        private _uihidden: boolean = null;
-        private _uiname: string = null;
-        private _uitype: string = null;
-        private _values: Array<Sdk.FetchXml.value> = [];
-
-        /**
-        * Gets or sets the aggregate value to apply to the condition.
-        */
-        public get aggregate(): Sdk.FetchXml.Aggregate {
-            return this._aggregate;
-        }
-        public set aggregate(value: Sdk.FetchXml.Aggregate) {
-            this._aggregate = value;
-        }
-        /**
-        * Gets or sets the alias value to apply to the condition.
-        */
-        public get alias(): string {
-            return this._alias;
-        }
-        public set alias(value: string) {
-            this._alias = value;
-        }
-        /**
-        * Gets or sets the attribute value to apply to the condition.
-        */
-        public get attribute(): string {
-            return this._attribute;
-        }
-        public set attribute(value: string) {
-            this._attribute = value;
-        }
-        /**
-        * Gets or sets the column attribute value to apply to the condition.
-        */
-        public get column(): string {
-            return this._column;
-        }
-        public set column(value: string) {
-            this._column = value;
-        }
-        /**
-       * Gets or sets the entityname attribute value to apply to the condition.
-       */
-        public get entityname(): string {
-            return this._entityname;
-        }
-        public set entityname(value: string) {
-            this._entityname = value;
-        }
-        /**
-       * Gets or sets the operator attribute value to apply to the condition.
-       */
-        public get operator(): Sdk.FetchXml.Operator {
-            return this._operator;
-        }
-        public set operator(value: Sdk.FetchXml.Operator) {
-            this._operator = value;
-        }
-        /**
-       * Gets or sets the rowAggregate attribute value to apply to the condition.
-       */
-        public get rowAggregate(): Sdk.FetchXml.RowAggregate {
-            return this._rowAggregate;
-        }
-        public set rowAggregate(value: Sdk.FetchXml.RowAggregate) {
-            this._rowAggregate = value;
-        }
-        /**
-       * Gets or sets the uihidden attribute value to apply to the condition.
-       */
-        public get uihidden(): boolean {
-            return this._uihidden;
-        }
-        public set uihidden(value: boolean) {
-            this._uihidden = value;
-        }
-        /**
-       * Gets or sets the uiname attribute value to apply to the condition.
-       */
-        public get uiname(): string {
-            return this._uiname;
-        }
-        public set uiname(value: string) {
-            this._uiname = value;
-        }
-        /**
-       * Gets or sets the uitype attribute value to apply to the condition.
-       */
-        public get uitype(): string {
-            return this._uitype;
-        }
-        public set uitype(value: string) {
-            this._uitype = value;
-        }
-        /**
-        * Gets or sets the array of values to be applied to the query results
-        */
-        public get values(): Array<Sdk.FetchXml.value> {
-            return this._values;
-        }
-        public set values(value: Array<Sdk.FetchXml.value>) {
-            if (!Sdk.FetchXml.Util.isValueArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.condition.values must be an array of Sdk.FetchXml.value or null.");
-            }
-            if (value == null) {
-                this._values = [];
-            } else {
-                this._values = value;
-            }
-        }
-        //Internal use only
-        public get hash(): string {
-            var s = this._attribute.concat(<string>this._operator,
-                (this._aggregate ? <string>this._aggregate : ""),
-                (this._alias ? this._alias : ""),
-                (this._column ? this._column : ""),
-                (this._entityname ? this._entityname : ""),
-                (this._rowAggregate ? <string>this._rowAggregate : ""),
-                (Sdk.FetchXml.Util.isNullOrUndefined(this._uihidden) ? "" : this._uihidden.toString()),
-                (this._uiname ? this._uiname : ""),
-                (this._uitype ? this._uitype : ""),
-                Sdk.FetchXml.Util.getCollectionHash(this._values)
-            );
-            return s.hashCode();
-        }
-
-        /** @description Sets the value of the condition attribute
-         * @param {string} attribute The attribute to evaluate in the condition.
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setAttribute(attributeName) {
-            this.attribute = attributeName;
-            return this;
-        }
-
-        /** @description Sets the value of the condition attribute
-         * @param {Sdk.FetchXml.Operator} operator The operator to use when evaluating the attribute.
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setOperator(operator) {
-            this.operator = operator;
-            return this;
-        }
-
-        /** @description Sets the value of the condition operator
-         * @param {Array} values The the value(s) to apply in the comparison.
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setValues(values) {
-            this.values = values;
-            return this;
-        }
-
-        /** @description Adds a value to the values to apply in the comparison
-         * @param {Sdk.FetchXml.value | any} value The the value to add to the values.
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public addValue(value) {
-            if (Sdk.FetchXml.Util.isValue(value)) {
-                this.values.push(value);
-            }
-            else {
-                this.values.push(new Sdk.FetchXml.value(value));
-            }
-            return this;
-        }
-
-        /** @description Removes any values from the values collection by reference
-        * @param {Sdk.FetchXml.value} value The value to remove from the values collection
-        * @returns {Sdk.FetchXml.condition}
-        */
-        public removeValueByRef(value) {
-            if (!Sdk.FetchXml.Util.isValue(value)) {
-                throw new Error("Sdk.FetchXml.condition removeValueByRef method value parameter must be an Sdk.FetchXml.value.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValueByRef(this.values, value);
-            return this;
-        }
-
-        /** @description Removes all matching values from the values collection
-        * @param {Sdk.FetchXml.value} value The value to remove from the values collection
-        * @returns {Sdk.FetchXml.condition}
-        */
-        public removeValue(value) {
-            if (!Sdk.FetchXml.Util.isValue(value)) {
-                throw new Error("Sdk.FetchXml.condition removeValue method value parameter must be an Sdk.FetchXml.value.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValue(this.values, value);
-            return this;
-        }
-
-        /** @description Removes all any values from the values collection with the specified value property
-        * @param {object} value The value to remove from the values collection
-        * @returns {Sdk.FetchXml.condition}
-        */
-        public removeValueByValue(value) {
-            Sdk.FetchXml.Util.removeCollectionValueByProperty(this.values, "value", value);
-            return this;
-        }
-
-        /** @description Sets the Aggregate to apply in the condition
-         * @param {Sdk.FetchXml.Aggregate} aggregate The Aggregate to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setAggregate(aggregate) {
-            this.aggregate = aggregate;
-            return this;
-        }
-
-        /** @description Sets the Alias to apply in the condition
-         * @param {string} alias The alias to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setAlias(alias) {
-            this.alias = alias;
-            return this;
-        }
-
-        /** @description Sets the Column to apply in the condition
-         * @param {string} column The column to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setColumn(column) {
-            this.column = column;
-            return this;
-        }
-
-        /** @description Sets the entityname to apply in the condition
-         * @param {string} entityname The entityname to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setEntityname(entityname) {
-            this.entityname = entityname;
-            return this;
-        }
-
-        /** @description Sets the rowAggregate to apply in the condition
-         * @param {Sdk.FetchXml.RowAggregate} rowAggregate The rowAggregate to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setRowAggregate(rowAggregate) {
-            this.rowAggregate = rowAggregate;
-            return this;
-        }
-
-        /** @description Sets the uihidden to apply in the condition
-         * @param {boolean | null} uihidden The uihidden to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setUIhidden(uihidden) {
-            this.uihidden = uihidden;
-            return this;
-        }
-
-        /** @description Sets the uiname to apply in the condition
-         * @param {string} uihidden The uiname to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setUIname(uiname) {
-            this.uiname = uiname;
-            return this;
-        }
-
-        /** @description Sets the uitype to apply in the condition
-         * @param {string} uitype The uitype to apply in the condition
-         * @returns {Sdk.FetchXml.condition}
-         */
-        public setUItype(uitype) {
-            this.uitype = uitype;
-            return this;
-        }
-
-        //Internal use only
-        toXml(doc: XMLDocument): Node {
-
-            var cNode = doc.createElement("condition");
-            if (this.aggregate) {
-                cNode.setAttribute("aggregate", <string>this.aggregate);
-            }
-            if (this.alias) {
-                cNode.setAttribute("alias", this.alias);
-            }
-            if (this.attribute) {
-                cNode.setAttribute("attribute", this.attribute);
-            }
-            if (this.column) {
-                cNode.setAttribute("column", this.column);
-            }
-            if (this.entityname) {
-                cNode.setAttribute("entityname", this.entityname);
-            }
-            if (this.operator) {
-                cNode.setAttribute("operator", <string>this.operator);
-            }
-            if (this.rowAggregate) {
-                cNode.setAttribute("rowAggregate", <string>this.rowAggregate);
-            }
-            if (Sdk.FetchXml.Util.isBoolean(this.uihidden)) {
-                cNode.setAttribute("uihidden", this.uihidden.toString());
-            }
-            if (this.uiname) {
-                cNode.setAttribute("uiname", this.uiname);
-            }
-            if (this.uitype) {
-                cNode.setAttribute("uitype", this.uitype);
-            }
-            /*
-    Note from fetch.xsd:
-        The attribute "value" is used for all operators that compare to a single value (for example, eq).
-        The element "value" is used for operators that compare to multiple values (for example, in).
-        Some operators require neither the attribute "value" or the element "value" (for example, null). 
-    
-       Groupings below are guesses and not confirmed.     
-            */
-            switch (this.operator) {
-                //Operators used for single values
-                case "begins-with":
-                case "ends-with":
-                case "eq":
-                case "ge":
-                case "gt":
-                case "last-x-days":
-                case "last-x-fiscal-periods":
-                case "last-x-fiscal-years":
-                case "last-x-hours":
-                case "last-x-months":
-                case "last-x-weeks":
-                case "last-x-years":
-                case "last-year":
-                case "le":
-                case "like":
-                case "lt":
-                case "ne":
-                case "neq": //Is this the same as 'ne'?
-                case "next-x-days":
-                case "next-x-fiscal-periods":
-                case "next-x-fiscal-years":
-                case "next-x-hours":
-                case "next-x-months":
-                case "next-x-weeks":
-                case "next-x-years":
-                case "not-begin-with":
-                case "not-end-with":
-                case "not-like":
-                case "olderthan-x-days":
-                case "olderthan-x-hours":
-                case "olderthan-x-minutes":
-                case "olderthan-x-months":
-                case "olderthan-x-weeks":
-                case "olderthan-x-years":
-                case "on":
-                case "on-or-after":
-                case "on-or-before":
-                case "in-fiscal-period":
-                case "in-fiscal-year":
-
-                    if (this.values.length == 1) {
-                        cNode.setAttribute("value", this.values[0].value);
-                    }
-                    else {
-                        var enumPropertyName = Sdk.FetchXml.Util.getEnumNameFromValue(Sdk.FetchXml.Operator, this.operator);
-                        throw new Error("Sdk.FetchXml.condition values property must contain single value when the Sdk.FetchXml.Operator." + enumPropertyName + " operator is used.");
-                    }
-                    break;
-                //Operators used for multiple values
-                case "between":
-                case "in":
-                case "not-between":
-                case "not-in":
-                case "in-fiscal-period-and-year":
-                case "in-or-after-fiscal-period-and-year":
-                case "in-or-before-fiscal-period-and-year":
-                    if (this.values.length > 1) {
-                        this.values.forEach(function (v) {
-                            cNode.appendChild(v.toXml(doc));
-                        });
-                    }
-                    else {
-                        var enumPropertyName = Sdk.FetchXml.Util.getEnumNameFromValue(Sdk.FetchXml.Operator, this.operator);
-                        throw new Error("Sdk.FetchXml.condition values property must contain multiple values when the Sdk.FetchXml.Operator." + enumPropertyName + " operator is used.");
-                    }
-                    break;
-                //Operators that require no values
-                case "above":
-                case "eq-businessid":
-                case "eq-or-above":
-                case "eq-or-under":
-                case "eq-userid": //?
-                case "eq-userlanguage": //?
-                case "eq-useroruserhierarchy":
-                case "eq-useroruserhierarchyandteams":
-                case "eq-useroruserteams":
-                case "eq-userteams":
-                case "last-fiscal-period":
-                case "last-fiscal-year":
-                case "last-month":
-                case "last-seven-days":
-                case "last-week":
-                case "ne-businessid"://?
-                case "ne-userid"://?
-                case "next-fiscal-period":
-                case "next-fiscal-year":
-                case "next-month":
-                case "next-seven-days":
-                case "next-week":
-                case "next-year":
-                case "not-null":
-                case "not-under":
-                case "null":
-                case "this-fiscal-period":
-                case "this-fiscal-year":
-                case "this-month":
-                case "this-week":
-                case "this-year":
-                case "today":
-                case "tomorrow":
-                case "under":
-                case "yesterday":
-                    //No value required
-                    if (this.values.length > 0) {
-                        var enumPropertyName = Sdk.FetchXml.Util.getEnumNameFromValue(Sdk.FetchXml.Operator, this.operator);
-                        console.log("Sdk.FetchXml.condition doesn't require values when the Sdk.FetchXml.Operator.%s operator is used. The values passed were ignored.", enumPropertyName);
-                    }
-
-                    break;
-                default:
-                    throw new Error(this.operator + " is an unexpected Sdk.FetchXml.Operator value.");
-                    break;
-            }
-
-            return cNode;
-        }
-        //Internal use only
-        static conditionFromXml(xml) {
-            var attributeName = xml.attributes.getNamedItem("attribute").nodeValue;
-            var operator = xml.attributes.getNamedItem("operator").nodeValue;
-
-            var conditionObj = new Sdk.FetchXml.condition(<string>attributeName, <Operator>operator);
-
-            Sdk.FetchXml.Util.parseAttributes(xml, conditionObj, (conditionObj, name, value) => {
-                switch (name) {
-                    case "column":
-                    case "entityname":
-                    case "aggregate":
-                    case "alias":
-                    case "uiname":
-                    case "uitype":
-                        conditionObj[name] = value;
-                        break;
-                    case "rowaggregate":
-                        conditionObj.rowAggregate = value;
-                        break;
-                    case "uihidden":
-                        conditionObj.uihidden = Util.convertFetchBoolType(value);
-                        break;
-                    case "value":
-                        conditionObj.addValue(value);
-                        break;
-                    default:
-                        break;
-                }
-            });
-
-            for (var i = 0; i < xml.childNodes.length; i++) {
-
-                if (xml.childNodes[i].nodeName == "value") {
-                    conditionObj.addValue(value.valueFromXml(xml.childNodes[i]));
-                }
-
-            }
-            return conditionObj;
-        }
-
-    }
-    @sealed
-    export class entity {
-        /**
-         * Contains the data for a fetchXml entity element.
-         * @param name The logical name of the attribute
-         * @param [attributes] The attributes to include with the entity
-         * @param [orders] The orders to apply to the query
-         * @param [filters] The filters to apply to the query
-         */
-        constructor(name: string, attributes?: Array<Sdk.FetchXml.attribute>, orders?: Array<Sdk.FetchXml.order>, filters?: Array<Sdk.FetchXml.filter>) {
-            if (!(this instanceof Sdk.FetchXml.entity))
-            { return new Sdk.FetchXml.entity(name, attributes, orders, filters); }
-
-            this.name = name;
-            if (attributes)
-                this.attributes = attributes;
-            if (orders)
-                this.orders = orders;
-            if (filters)
-                this.filters = filters;
-        }
-
-        private _allAttributes: boolean = null;
-        private _attributes: Array<Sdk.FetchXml.attribute> = [];
-        private _orders: Array<Sdk.FetchXml.order> = [];
-        private _linkEntities: Array<Sdk.FetchXml.linkEntity> = [];
-        private _filters: Array<Sdk.FetchXml.filter> = [];
-        private _name: string;
-
-        /**
-        * Gets or sets whether all attributes for the entity should be returned
-        */
-        public get allAttributes(): boolean {
-            return this._allAttributes;
-        }
-        public set allAttributes(value: boolean) {
-            if (!Sdk.FetchXml.Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.entity.allAttributes must be a boolean value or null.");
-            }
-            this._allAttributes = value;
-        }
-        /**
-        * Gets or sets the array of attribute of the entity to be returned in the query results
-        */
-        public get attributes(): Array<Sdk.FetchXml.attribute> {
-            return this._attributes;
-        }
-        public set attributes(value: Array<Sdk.FetchXml.attribute>) {
-            if (!Sdk.FetchXml.Util.isAttributeArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.entity.attributes must be an array of Sdk.FetchXml.attribute or null.");
-            }
-            if (value == null) {
-                this._attributes = [];
-            } else {
-                this._attributes = value;
-            }
-
-        }
-        /**
-        * Gets or sets the array of attribute of the entity to be returned in the query results
-        */
-        public get orders(): Array<Sdk.FetchXml.order> {
-            return this._orders;
-        }
-        public set orders(value: Array<Sdk.FetchXml.order>) {
-            if (!Sdk.FetchXml.Util.isOrderArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.entity.orders must be an array of Sdk.FetchXml.order or null.");
-            }
-            if (value == null) {
-                this._orders = [];
-            } else {
-                this._orders = value;
-            }
-
-        }
-        /**
-        * Gets or sets the array of related entities to be returned in the query results
-        */
-        public get linkEntities(): Array<Sdk.FetchXml.linkEntity> {
-            return this._linkEntities;
-        }
-        public set linkEntities(value: Array<Sdk.FetchXml.linkEntity>) {
-            if (!Sdk.FetchXml.Util.isLinkEntityArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.entity.linkEntities must be an array of Sdk.FetchXml.linkEntity or null.");
-            }
-            if (value == null) {
-                this._linkEntities = [];
-            } else {
-                this._linkEntities = value;
-            }
-
-        }
-        /**
-        * Gets or sets the array of filters to be applied to the query results
-        */
-        public get filters(): Array<Sdk.FetchXml.filter> {
-            return this._filters;
-        }
-        public set filters(value: Array<Sdk.FetchXml.filter>) {
-            if (!Sdk.FetchXml.Util.isFilterArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.entity.filters must be an array of Sdk.FetchXml.filter or null.");
-            }
-            if (value == null) {
-                this._filters = [];
-            } else {
-                this._filters = value;
-            }
-
-        }
-        /**
-        * Gets or sets the logical name of the entity
-        */
-        public get name(): string {
-            return this._name;
-        }
-        public set name(value: string) {
-            if (!Sdk.FetchXml.Util.isString(value)) {
-                throw new Error("Sdk.FetchXml.entity.name must be a string.");
-            }
-            this._name = value;
-
-        }
-
-        /** @description Adds an attribute to the attribute collection
-        * @param {Sdk.FetchXml.attribute | string} attributeOrAttributeName the attribute or attribute name to add
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public addAttribute(attributeOrAttributeName: Sdk.FetchXml.attribute | string) {
-            if (Sdk.FetchXml.Util.isString(attributeOrAttributeName)) {
-
-                // Some saved queries have duplicate attributes defined, so this is a bit more strict than it has to be.
-                var exists = false;
-                this.attributes.forEach(function (a) {
-                    if (a.name == attributeOrAttributeName) {
-                        exists = true;
-                    }
-                });
-                if (!exists) {
-                    this.attributes.push(new Sdk.FetchXml.attribute(<string>attributeOrAttributeName));
-                }
-                return this;
-            }
-            if (Sdk.FetchXml.Util.isAttribute(attributeOrAttributeName)) {
-                var exists = false;
-                this.attributes.forEach(function (a) {
-                    if (a.name == (<Sdk.FetchXml.attribute>attributeOrAttributeName).name) {
-                        exists = true;
-                    }
-                });
-                if (!exists) {
-                    this.attributes.push(<Sdk.FetchXml.attribute>attributeOrAttributeName);
-                }
-            }
-            else {
-                throw new Error("Sdk.FetchXml.entity addAttribute method attributeOrAttributeName parameter must be an Sdk.FetchXml.attribute or a string value.");
-            }
-            return this;
-        }
-
-        /** @description Removes an attribute from the attributes collection by name
-        * @param {string} attributeName The name of the attribute to remove
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeAttributeByName(attributeName: string) {
-            Sdk.FetchXml.Util.removeCollectionValueByProperty(this.attributes, "name", attributeName);
-        }
-
-        /** @description Removes an attribute from the attributes collection by reference
-        * @param {Sdk.FetchXml.attribute} attribute The attribute to remove
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeAttributeByRef(attribute: Sdk.FetchXml.attribute) {
-            Sdk.FetchXml.Util.removeCollectionValueByRef(this.attributes, attribute);
-        }
-
-        /** @description Removes an attribute from the attributes collection
-        * @param {Sdk.FetchXml.attribute} attribute The attribute to remove
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeAttribute(attribute: Sdk.FetchXml.attribute) {
-            Sdk.FetchXml.Util.removeCollectionValue(this.attributes, attribute);
-        }
-
-        /** @description Adds an order to the orders collection
-        * @param {Sdk.FetchXml.order | string} orderOrAttribute The order to add to the attributes collection or the Attribute property of a new order to create
-        * @param {boolean} descending Whether the order is descending. True if descending, otherwise false
-        * @param {string} alias The alias to set for the order
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public addOrder(orderOrAttribute: any, descending?, alias?) {
-            if (Sdk.FetchXml.Util.isOrder(orderOrAttribute)) {
-                this.orders.push(orderOrAttribute);
-                return this;
-            }
-            if (Sdk.FetchXml.Util.isString(orderOrAttribute)) {
-                this.orders.push(new Sdk.FetchXml.order(orderOrAttribute, descending, alias));
-            }
-            else {
-                throw new Error("Sdk.FetchXml.entity addOrder method orderOrAttribute parameter must be a Sdk.FetchXml.order value or a string.");
-            }
-            return this;
-        }
-
-        /** @description Removes a order from the orders collection by reference
-        * @param {Sdk.FetchXml.order} order The order to remove from the orders collection
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeOrderByRef(order: Sdk.FetchXml.order) {
-            if (!Sdk.FetchXml.Util.isOrder(order)) {
-                throw new Error("Sdk.FetchXml.entity removeOrderByRef method order parameter must be an Sdk.FetchXml.order.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValueByRef(this.orders, order);
-            return this;
-        }
-
-        /** @description Removes a order from the orders collection by value
-        * @param {Sdk.FetchXml.order} order The order to remove from the orders collection
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeOrder(order) {
-            if (!Sdk.FetchXml.Util.isOrder(order)) {
-                throw new Error("Sdk.FetchXml.entity removeOrder method order parameter must be an Sdk.FetchXml.order.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValue(this.orders, order);
-            return this;
-        }
-
-        /** @description Sets the name property of the entity element
-        * @param {string} name The name value to apply to the entity
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public setName(name: string) {
-            this.name = name;
-            return this;
-        }
-
-        /** @description Sets the allAttributes property of the entity 
-        * @param {boolean} [allAttributes] The allAttributes value to apply to the entity. The default is true;
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public setAllAttributes(allAttributes?: boolean) {
-            if (Sdk.FetchXml.Util.isBoolean(allAttributes)) {
-                this.allAttributes = allAttributes;
-            }
-            else {
-                if (Sdk.FetchXml.Util.isNullOrUndefined(allAttributes)) {
-                    this.allAttributes = true;
-                }
-                else {
-                    throw new Error("Sdk.FetchXml.entity setAllAttributes method allAttributes parameter must be a boolean value or null.");
-                }
-            }
-
-            return this;
-        }
-
-        /** @description Adds an linkEntity to the linkEntities collection
-        * @param {Sdk.FetchXml.linkEntity} linkEntity The linkEntity to add to the entity
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public addLinkEntity(linkEntity: Sdk.FetchXml.linkEntity) {
-            if (Sdk.FetchXml.Util.isLinkEntity(linkEntity)) {
-                this.linkEntities.push(linkEntity);
-                return this;
-            }
-            else {
-                throw new Error("Sdk.FetchXml.entity addLinkEntity method linkEntity parameter must be a Sdk.FetchXml.linkEntity value.");
-            }
-            return this;
-        }
-
-        /** @description Removes a linkEntity from the linkEntities collection by reference
-        * @param {Sdk.FetchXml.linkEntity} linkEntity The linkEntity to remove from the linkEntities collection
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeLinkEntityByRef(linkEntity: Sdk.FetchXml.linkEntity) {
-            if (!Sdk.FetchXml.Util.isLinkEntity(linkEntity)) {
-                throw new Error("Sdk.FetchXml.entity removeLinkEntityByRef method linkEntity parameter must be an Sdk.FetchXml.linkEntity.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValueByRef(this.linkEntities, linkEntity);
-            return this;
-        }
-
-        /** @description Removes a linkEntity from the linkEntities collection by value
-        * @param {Sdk.FetchXml.linkEntity} linkEntity The linkEntity to remove from the linkEntities collection
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeLinkEntity(linkEntity: Sdk.FetchXml.linkEntity) {
-            if (!Sdk.FetchXml.Util.isLinkEntity(linkEntity)) {
-                throw new Error("Sdk.FetchXml.entity removeLinkEntity method linkEntity parameter must be an Sdk.FetchXml.linkEntity.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValue(this.linkEntities, linkEntity);
-            return this;
-        }
-
-        /** @description Adds an filter to the filters collection
-       * @param {Sdk.FetchXml.filter} filter The filter to add to the entity
-       * @returns {Sdk.FetchXml.entity}
-       */
-        public addFilter(filter: Sdk.FetchXml.filter) {
-            if (Sdk.FetchXml.Util.isFilter(filter)) {
-                this.filters.push(filter);
-                return this;
-            }
-            else {
-                throw new Error("Sdk.FetchXml.entity addFilter method filter parameter must be a Sdk.FetchXml.filter value.");
-            }
-            return this;
-        }
-
-        /** @description Removes a filter from the filters collection by reference
-        * @param {Sdk.FetchXml.filter} filter The filter to remove from the filters collection
-        * @returns {Sdk.FetchXml.entity}
-        */
-        public removeFilterByRef(filter: Sdk.FetchXml.filter) {
-            if (!Sdk.FetchXml.Util.isFilter(filter)) {
-                throw new Error("Sdk.FetchXml.entity removeFilterByRef method filter parameter must be an Sdk.FetchXml.filter.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValueByRef(this.filters, filter);
-            return this;
-        }
-
-        /** @description Removes a filter from the filters collection by value
-         * @param {Sdk.FetchXml.filter} filter The filter to remove from the filters collection
-         * @returns {Sdk.FetchXml.entity}
-         */
-        public removeFilter(filter: Sdk.FetchXml.filter) {
-            if (!Sdk.FetchXml.Util.isFilter(filter)) {
-                throw new Error("Sdk.FetchXml.entity removeFilter method filter parameter must be an Sdk.FetchXml.filter.");
-            }
-            Sdk.FetchXml.Util.removeCollectionValue(this.filters, filter);
-            return this;
-        }
-
-        //internal use only
-        toXml(doc: XMLDocument): Node {
-            var entityNode = doc.createElement("entity");
-            if (this.allAttributes) {
-                entityNode.appendChild(doc.createElement("all-attributes"));
-            }
-            else {
-                this.attributes.forEach(function (a, i) {
-                    entityNode.appendChild(a.toXml(doc));
-                });
-            }
-            this.orders.forEach(function (o, i) {
-                entityNode.appendChild(o.toXml(doc));
-            });
-
-            this.linkEntities.forEach(function (l, i) {
-                entityNode.appendChild(l.toXml(doc));
-            });
-
-            this.filters.forEach(function (f, i) {
-                entityNode.appendChild(f.toXml(doc));
-            });
-
-            //Is required so no need to check
-            entityNode.setAttribute("name", this.name);
-
-            return entityNode;
-        }
-        //Internal use only
-        static entityFromXml(xml) {
-            var entityObj = new Sdk.FetchXml.entity(xml.attributes.getNamedItem("name").nodeValue);
-            entityObj.allAttributes = (xml.getElementsByTagName("all-attributes").length == 1);
-
-            for (var i = 0; i < xml.childNodes.length; i++) {
-
-                if (xml.childNodes[i].nodeName == "attribute") {
-                    entityObj.addAttribute(attribute.attributeFromXml(xml.childNodes[i]));
-                }
-                if (xml.childNodes[i].nodeName == "order") {
-
-                    entityObj.addOrder(order.orderFromXml(xml.childNodes[i]));
-                }
-                if (xml.childNodes[i].nodeName == "link-entity") {
-                    entityObj.addLinkEntity(linkEntity.linkEntityFromXml(xml.childNodes[i]));
-                }
-                if (xml.childNodes[i].nodeName == "filter") {
-                    entityObj.addFilter(filter.filterFromXml(xml.childNodes[i]));
-                }
-
-            }
-
-            return entityObj;
-        }
-
-    }
-    @sealed
-    export class fetch {
-
-        /**
-        * Contains the data for a fetchXml fetch element.
-        * @param entity The entity that is being queried
-        */
-        constructor(entity?: Sdk.FetchXml.entity) {
-            //new keyword not required
-            if (!(this instanceof Sdk.FetchXml.fetch))
-            { return new Sdk.FetchXml.fetch(entity); }
-            if (entity)
-                this.entity = entity;
-        }
-
-        private _aggregate: boolean = null;
-        private _count: number = null;
-        private _distinct: boolean = null;
-        private _entity: Sdk.FetchXml.entity;
-        private _mapping: Sdk.FetchXml.Mapping = null;
-        private _minActiveRowVersion: boolean = null;
-        private _noLock: boolean = null;
-        private _order: Sdk.FetchXml.order = null;
-        private _outputFormat: Sdk.FetchXml.OutputFormat = null;
-        private _page: number = null;
-        private _pagingCookie: string = null;
-        private _returnTotalRecordCount: boolean = null;
-        private _top: number = null;
-        private _utcOffset: number = null;
-        private _version: string = null;
-
-        /**
-        * Gets or sets the aggregate attribute of the fetch element.
-        */
-        public get aggregate(): boolean {
-            return this._aggregate;
-        }
-        public set aggregate(value: boolean) {
-            if (!Sdk.FetchXml.Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.aggregate must be a boolean value or null.");
-            }
-            this._aggregate = value;
-        }
-        /**
-        * Gets or sets the count attribute of the fetch element.
-        */
-        public get count(): number {
-            return this._count;
-        }
-        public set count(value: number) {
-            if (!Sdk.FetchXml.Util.isNumberOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.count must be a number value or null.");
-            }
-            this._count = value;
-        }
-        /**
-        * Gets or sets the distinct attribute of the fetch element.
-        */
-        public get distinct(): boolean {
-            return this._distinct;
-        }
-        public set distinct(value: boolean) {
-            if (!Sdk.FetchXml.Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.distinct must be a boolean value or null.");
-            }
-            this._distinct = value;
-        }
-        /**
-        * Gets or sets the entity attribute of the fetch element.
-        */
-        public get entity(): Sdk.FetchXml.entity {
-            return this._entity;
-        }
-        public set entity(value: Sdk.FetchXml.entity) {
-            if (!Sdk.FetchXml.Util.isEntity(value)) {
-                throw new Error("Sdk.FetchXml.fetch.entity must be a Sdk.FetchXml.entity value.");
-            }
-            this._entity = value;
-        }
-        /**
-        * Gets or sets the mapping attribute of the fetch element.
-        */
-        public get mapping(): Sdk.FetchXml.Mapping {
-            return this._mapping;
-        }
-        public set mapping(value: Sdk.FetchXml.Mapping) {
-            if (!Sdk.FetchXml.Util.isEnumMemberOrNull(Sdk.FetchXml.Mapping, value)) {
-                throw new Error("Sdk.FetchXml.fetch.mapping must be a Sdk.FetchXml.Mapping value or null.");
-            }
-            this._mapping = value;
-        }
-        /**
-        * Gets or sets the minActiveRowVersion attribute of the fetch element.
-        */
-        public get minActiveRowVersion(): boolean {
-            return this._minActiveRowVersion;
-        }
-        public set minActiveRowVersion(value: boolean) {
-            if (!Sdk.FetchXml.Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.minActiveRowVersion must be a boolean value or null.");
-            }
-            this._minActiveRowVersion = value;
-        }
-        /**
-        * Gets or sets the noLock attribute of the fetch element.
-        */
-        public get noLock(): boolean {
-            return this._noLock;
-        }
-        public set noLock(value: boolean) {
-            if (!Sdk.FetchXml.Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.noLock must be a boolean value or null.");
-            }
-            this._noLock = value;
-        }
-        /**
-        * Gets or sets the order attribute of the fetch element.
-        */
-        public get order(): Sdk.FetchXml.order {
-            return this._order;
-        }
-        public set order(value: Sdk.FetchXml.order) {
-            if (!Sdk.FetchXml.Util.isOrderOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.order must be a Sdk.FetchXml.order value or null.");
-            }
-            this._order = value;
-        }
-        /**
-        * Gets or sets the outputFormat attribute of the fetch element.
-        */
-        public get outputFormat(): Sdk.FetchXml.OutputFormat {
-            return this._outputFormat;
-        }
-        public set outputFormat(value: Sdk.FetchXml.OutputFormat) {
-            if (!Sdk.FetchXml.Util.isEnumMemberOrNull(Sdk.FetchXml.OutputFormat, value)) {
-                throw new Error("Sdk.FetchXml.fetch.outputFormat must be a Sdk.FetchXml.OutputFormat value or null.");
-            }
-            this._outputFormat = value;
-        }
-        /**
-        * Gets or sets the page attribute of the fetch element.
-        */
-        public get page(): number {
-            return this._page;
-        }
-        public set page(value: number) {
-            if (!Sdk.FetchXml.Util.isNumberOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.page must be a number value or null.");
-            }
-            this._page = value;
-        }
-        /**
-        * Gets or sets the pagingCookie attribute of the fetch element.
-        */
-        public get pagingCookie(): string {
-            return this._pagingCookie;
-        }
-        public set pagingCookie(value: string) {
-            if (!Sdk.FetchXml.Util.isStringOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.pagingCookie must be a string value or null.");
-            }
-            this._pagingCookie = value;
-        }
-        /**
-        * Gets or sets the returnTotalRecordCount attribute of the fetch element.
-        */
-        public get returnTotalRecordCount(): boolean {
-            return this._returnTotalRecordCount;
-        }
-        public set returnTotalRecordCount(value: boolean) {
-            if (!Sdk.FetchXml.Util.isBooleanOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.returnTotalRecordCount must be a boolean value or null.");
-            }
-            this._returnTotalRecordCount = value;
-        }
-        /**
-        * Gets or sets the top attribute of the fetch element.
-        */
-        public get top(): number {
-            return this._top;
-        }
-        public set top(value: number) {
-            if (!Sdk.FetchXml.Util.isNumberOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.top must be a number value or null.");
-            }
-            this._top = value;
-        }
-        /**
-        * Gets or sets the utcOffset attribute of the fetch element.
-        */
-        public get utcOffset(): number {
-            return this._utcOffset;
-        }
-        public set utcOffset(value: number) {
-            if (!Sdk.FetchXml.Util.isNumberOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.utcOffset must be a number value or null.");
-            }
-            this._utcOffset = value;
-        }
-        /**
-        * Gets or sets the version attribute of the fetch element.
-        */
-        public get version(): string {
-            return this._version;
-        }
-        public set version(value: string) {
-            if (!Sdk.FetchXml.Util.isStringOrNull(value)) {
-                throw new Error("Sdk.FetchXml.fetch.version must be a string value or null.");
-            }
-            this._version = value;
-        }
-
-        /** @description Sets the aggregate attribute of the fetch element
-        * @param {boolean | null} aggregate The aggregate value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setAggregate(aggregate?: boolean) {
-            (aggregate) ? this.aggregate = aggregate : this.aggregate = null;
-            return this;
-        }
-
-        /** @description Sets the count attribute of the fetch element
-        * @param {number | null} count The count value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setCount(count?: number) {
-            (count) ? this.count = count : this.count = null;
-            return this;
-        }
-
-        /** @description Sets the distinct attribute of the fetch element
-        * @param {boolean | null} distinct The distinct value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setDistinct(distinct?: boolean) {
-            (distinct) ? this.distinct = distinct : this.distinct = null;
-            return this;
-        }
-
-        /** @description Sets the aggregate entity of the fetch element
-        * @param {Sdk.FetchXml.entity} entity The entity value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setEntity(entity: Sdk.FetchXml.entity) {
-            this.entity = entity;
-            return this;
-        }
-
-        /** @description Sets the mapping attribute of the fetch element
-        * @param {Sdk.FetchXml.Mapping} mapping The mapping value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setMapping(mapping?: Sdk.FetchXml.Mapping) {
-            (mapping) ? this.mapping = mapping : this.mapping = null;
-            return this;
-        }
-
-        /** @description Sets the minActiveRowVersion attribute of the fetch element
-        * @param {boolean | null} minActiveRowVersion The minActiveRowVersion value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setMinActiveRowVersion(minActiveRowVersion?: boolean) {
-            (minActiveRowVersion) ? this.minActiveRowVersion = minActiveRowVersion : this.minActiveRowVersion = null;
-            return this;
-        }
-
-        /** @description Sets the noLock attribute of the fetch element
-        * @param {boolean | null} noLock The noLock value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setNoLock(noLock: boolean = null) {
-            this.noLock = noLock;
-            return this;
-        }
-
-        /** @description Sets the order attribute of the fetch element
-        * @param {Sdk.FetchXml.order | null} order The order value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setOrder(order: Sdk.FetchXml.order = null) {
-            this.order = order;
-            return this;
-        }
-
-        /** @description Sets the outputFormat attribute of the fetch element
-        * @param {Sdk.FetchXml.OutputFormat | null} outputFormat The outputFormat value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setOutputFormat(outputFormat?: Sdk.FetchXml.OutputFormat) {
-            (outputFormat) ? this.outputFormat = outputFormat : this.outputFormat = null;
-            return this;
-        }
-
-        /** @description Sets the page attribute of the fetch element
-        * @param {number | null} page The page value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setPage(page?: number) {
-            (page) ? this.page = page : this.page = null;
-            return this;
-        }
-
-        /** @description Sets the pagingCookie attribute of the fetch element
-        * @param {string | null} pagingCookie The pagingCookie value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setPagingCookie(pagingCookie: string = null) {
-            this.pagingCookie = pagingCookie;
-            return this;
-        }
-
-        /** @description Sets the returnTotalRecordCount attribute of the fetch element
-        * @param {boolean} returnTotalRecordCount The returnTotalRecordCount value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setReturnTotalRecordCount(returnTotalRecordCount?: boolean) {
-            (returnTotalRecordCount) ? this.returnTotalRecordCount = returnTotalRecordCount : this.returnTotalRecordCount = null;
-            return this;
-        }
-
-        /** @description Sets the top attribute of the fetch element
-        * @param {number | null} top The top value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setTop(top?: number) {
-            (top) ? this.top = top : this.top = null;
-            return this;
-        }
-
-        /** @description Sets the utcOffset attribute of the fetch element
-        * @param {number | null} utcOffset The utcOffset value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setUtcOffset(utcOffset?: number) {
-            (utcOffset) ? this.utcOffset = utcOffset : this.utcOffset = null;
-            return this;
-        }
-
-        /** @description Sets the version attribute of the fetch element
-        * @param {string | null} version The version value to apply to the fetch element
-        * @returns {Sdk.FetchXml.fetch}
-        */
-        public setVersion(version?: string) {
-            (version) ? this.version = version : this.version = null;
-            return this;
-        }
-
-        /**
-        * Serializes the fetch query into a FetchXML string
-        */
-        public toXml(): string {
-
-            var root = "<fetch />";
-            var doc = new DOMParser().parseFromString(root, "text/xml");
-            if (this.version) {
-                doc.documentElement.setAttribute("version", <string>this.version);
-            }
-            if (this.outputFormat) {
-                doc.documentElement.setAttribute("output-format", <string>this.outputFormat);
-            }
-            if (this.mapping) {
-                doc.documentElement.setAttribute("mapping", <string>this.mapping);
-            }
-            if (this.aggregate) {
-                doc.documentElement.setAttribute("aggregate", (this.aggregate) ? "true" : "false");
-            }
-            if (this.count) {
-                doc.documentElement.setAttribute("count", this.count.toString());
-            }
-            if (this.distinct) {
-                doc.documentElement.setAttribute("distinct", (this.distinct) ? "true" : "false");
-            }
-            if (this.entity) {
-                doc.documentElement.appendChild(this.entity.toXml(doc));
-            }
-
-            if (this.minActiveRowVersion) {
-                doc.documentElement.setAttribute("min-active-row-version", (this.minActiveRowVersion) ? "true" : "false");
-            }
-            if (this.noLock) {
-                doc.documentElement.setAttribute("no-lock", (this.noLock) ? "true" : "false");
-            }
-            if (this.order) {
-                doc.documentElement.appendChild(this.order.toXml(doc));
-            }
-
-            if (this.page) {
-                doc.documentElement.setAttribute("page", this.page.toString());
-            }
-            if (this.pagingCookie) {
-                doc.documentElement.setAttribute("paging-cookie", <string>this.pagingCookie); //Does this need special handling?
-            }
-            if (this.returnTotalRecordCount) {
-                doc.documentElement.setAttribute("returntotalrecordcount", (this.returnTotalRecordCount) ? "true" : "false");
-            }
-            if (this.top) {
-                doc.documentElement.setAttribute("top", this.top.toString());
-            }
-            if (this.utcOffset) {
-                doc.documentElement.setAttribute("utc-offset", this.utcOffset.toString());
-            }
-
-            return new XMLSerializer().serializeToString(doc);
-        }
-        /**
-         * Instantiates a fetch object from a fetchXml string
-         * @param xml A FetchXML string
-         * @returns Sdk.FetchXml.fetch
-         */
-        public static fromXml(xml: string) {
-            var doc = new DOMParser().parseFromString(xml, "text/xml");
-            var fetchObj = new Sdk.FetchXml.fetch();
-            var errorMessage = "The XML string is not a valid fetchXML document";
-
-            if (doc.documentElement.localName == "fetch") {
-
-                Sdk.FetchXml.Util.parseAttributes(doc.documentElement, fetchObj, (fetchObj, name, value) => {
-                    switch (name) {
-                        case "count":
-                        case "top":
-                        case "page":
-                            fetchObj[name] = parseInt(value, 10);
-                            break;
-                        case "utc-offset":
-                            if (!isNaN(value)) {
-                                fetchObj.utcOffset = parseInt(value, 10);
-                            }
-                            else {
-                                fetchObj.utcOffset = null;
-                            }
-                            break;
-                        case "paging-cookie":
-                            fetchObj.pagingCookie = value;
-                            break;
-                        case "min-active-row-version":
-                            fetchObj.minActiveRowVersion = (value == "true") ? true : false;
-                            break;
-                        case "output-format":
-                            fetchObj.outputFormat = value;
-                            break;
-                        case "returntotalrecordcount":
-                            fetchObj.returnTotalRecordCount = (value == "true") ? true : false;
-                            break;
-                        case "no-lock":
-                            fetchObj.noLock = (value == "true") ? true : false;
-                            break;
-                        case "aggregate": //xs:boolean
-                        case "distinct":
-                            fetchObj[name] = (value == "true") ? true : false;
-                            break;
-                        default:
-                            fetchObj[name] = value;
-                            break;
-                    }
-                });
-
-                for (var i = 0; i < doc.documentElement.childNodes.length; i++) {
-
-                    if (doc.documentElement.childNodes[i].nodeName == "entity") {
-                        fetchObj.entity = Sdk.FetchXml.entity.entityFromXml(doc.documentElement.childNodes[i]);
-                    }
-                    if (doc.documentElement.childNodes[i].nodeName == "order") {
-                        fetchObj.order = Sdk.FetchXml.order.orderFromXml(doc.documentElement.childNodes[i]);
-                    }
-                }
-
-            }
-            else {
-                throw new Error(errorMessage);
-            }
-
-            return fetchObj;
-        }
-
-    }
-    @sealed
-    export class filter {
-        /** @description Contains the data for a fetchXml filter element.
-        * @param  [type] The type of filter: 'and' or 'or'. Default is 'and'
-        * @param  [conditions] An array of Sdk.FetchXml.condition to apply to the filter
-        * @param  [filters] An array of Sdk.FetchXml.filter to apply to the filter
-        * @property  conditions Gets or sets the array of Sdk.FetchXml.condition to apply in the filter
-        * @property  filters Gets or sets the array of Sdk.FetchXml.filter to apply to the filter
-        * @property  type Gets or sets the type of filter.
-        * @property  isQuickFindFields Gets or sets the isQuickFindFields property of the filter
-        * @returns {Sdk.FetchXml.filter}
-        */
-        constructor(type?: string, conditions?: Array<condition>, filters?: Array<filter>) {
-            //new keyword is not required in JS
-            if (!(this instanceof filter))
-            { return new filter(type, conditions, filters); }
-            if (type)
-                this.type = type;
-            if (conditions)
-                this.conditions = conditions;
-            if (filters)
-                this.filters = filters;
-        }
-
-        private _conditions: Array<condition> = [];
-        private _filters: Array<filter> = [];
-        private _type: FilterType = null;
-        private _isQuickFindFields: boolean = null;
-
-        /**
-        * Gets or sets the array of condition to be applied to the query results
-        */
-        public get conditions(): Array<condition> {
-            return this._conditions;
-        }
-        public set conditions(value: Array<condition>) {
-            if (!Util.isFilterArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.filter.conditions must be an array of Sdk.FetchXml.condition or null.");
-            }
-            if (value == null) {
-                this._conditions = [];
-            } else {
-                this._conditions = value;
-            }
-        }
-        /**
-        * Gets or sets the array of filters to be applied to the query results
-        */
-        public get filters(): Array<filter> {
-            return this._filters;
-        }
-        public set filters(value: Array<filter>) {
-            if (!Util.isFilterArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.filter.filters must be an array of Sdk.FetchXml.filter or null.");
-            }
-            if (value == null) {
-                this._filters = [];
-            } else {
-                this._filters = value;
-            }
-        }
-        /**
-       * Gets or sets the type property of the filter
-       */
-        public get type(): FilterType {
-            return this._type;
-        }
-        public set type(value: FilterType) {
-            this._type = value;
-        }
-        /**
-       * Gets or sets the isQuickFindFields property of the filter
-       */
-        public get isQuickFindFields(): boolean {
-            return this._isQuickFindFields;
-        }
-        public set isQuickFindFields(value: boolean) {
-            this._isQuickFindFields = value;
-        }
-
-        /** @description Adds a condition to the conditions collection
-        * @param {Sdk.FetchXml.attribute | Sdk.FetchXml.condition} attributeOrCondition When Sdk.FetchXml.condition the condition is added. 
-          When Sdk.FetchXml.attribute, the attribute property of a new condition
-        * @param {Sdk.FetchXml.Operator} [operator] The operator property for a new condition. Required when the first parameter is an Sdk.FetchXml.attribute
-        * @param {Array} [values] The values to compare for a new condition.
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public addCondition(attributeOrCondition: any, operator?, values?) {
-            if (Util.isCondition(attributeOrCondition)) {
-                this.conditions.push(attributeOrCondition);
-            }
-            else {
-                this.conditions.push(new condition(attributeOrCondition, operator, values));
-            }
-
-            return this;
-        }
-
-        /** @description Removes a condition from the conditions collection by reference
-        * @param {Sdk.FetchXml.condition} condition The condition to remove from the conditions collection
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public removeConditionByRef(condition) {
-            if (!Util.isCondition(condition)) {
-                throw new Error("Sdk.FetchXml.filter removeConditionByRef method condition parameter must be an Sdk.FetchXml.condition.");
-            }
-            Util.removeCollectionValueByRef(this.conditions, condition);
-
-            return this;
-        }
-
-        /** @description Removes a condition from the conditions collection by value
-        * @param {Sdk.FetchXml.condition} condition The condition to remove from the conditions collection
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public removeCondition(condition) {
-            if (!Util.isCondition(condition)) {
-                throw new Error("Sdk.FetchXml.filter removeCondition method condition parameter must be an Sdk.FetchXml.condition.");
-            }
-            Util.removeCollectionValue(this.conditions, condition);
-
-            return this;
-        }
-
-        /** @description Adds a filter to the filters collection
-        * @param {Sdk.FetchXml.filter} filter The filter to add to the filters collectio
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public addFilter(filter) {
-            if (Util.isFilter(filter)) {
-                this.filters.push(filter);
-
-            } else {
-                throw new Error("Sdk.FetchXml.filter addFilter method filter parameter must be a Sdk.FetchXml.filter value.");
-            }
-            return this;
-        }
-
-        /** @description Removes all references to a filter object
-        * @param {Sdk.FetchXml.filter} filter The filter to remove from the filters collectio
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public removeFilterByRef(filter) {
-            if (!Util.isFilter(filter)) {
-                throw new Error("Sdk.FetchXml.filter removeFilterByRef method filter parameter must be an Sdk.FetchXml.filter.");
-            }
-            Util.removeCollectionValueByRef(this.filters, filter);
-
-            return this;
-        }
-
-        /** @description Removes all matching filters from the filters collection
-        * @param {Sdk.FetchXml.filter} filter The filter to remove from the filters collectio
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public removeFilter(filter) {
-            if (!Util.isFilter(filter)) {
-                throw new Error("Sdk.FetchXml.filter removeFilter method filter parameter must be an Sdk.FetchXml.filter.");
-            }
-            Util.removeCollectionValue(this.filters, filter);
-
-            return this;
-        }
-
-        /** @description Sets the isQuickFindFields property
-        * @param {boolean | null} value The value to set
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public setIsQuickFindFields(value) {
-            this.isQuickFindFields = value;
-            return this;
-        }
-
-        /** @description Sets the type property
-        * @param {Sdk.FetchXml.FilterType} value The value to set
-        * @returns {Sdk.FetchXml.filter}
-        */
-        public setType(value) {
-            this.type = value;
-            return this;
-        }
-
-        //Internal use only
-        toXml(doc: XMLDocument): Node {
-            var fNode = doc.createElement("filter");
-            if (this.type) {
-                fNode.setAttribute("type", <string>this.type);
-            }
-            if (Util.isBoolean(this.isQuickFindFields)) {
-                fNode.setAttribute("isquickfindfields", this.isQuickFindFields.toString());
-            }
-            this.conditions.forEach(function (c) {
-                fNode.appendChild(c.toXml(doc));
-            });
-            this.filters.forEach(function (f) {
-                fNode.appendChild(f.toXml(doc));
-            });
-            return fNode;
-        }
-
-        static filterFromXml(xml) {
-            var filterObj = new filter();
-
-            Util.parseAttributes(xml, filterObj, (filterObj, name, value) => {
-                switch (name) {
-                    case "type":
-                        filterObj.type = value;
-                        break;
-                    case "isquickfindfields":
-                        filterObj.isQuickFindFields = (value == "true" || value == "1") ? true : false;
-                        break;
-                    default:
-                        break;
-                }
-            });
-
-            for (var i = 0; i < xml.childNodes.length; i++) {
-
-                if (xml.childNodes[i].nodeName == "condition") {
-                    filterObj.addCondition(condition.conditionFromXml(xml.childNodes[i]));
-                }
-
-                if (xml.childNodes[i].nodeName == "filter") {
-                    filterObj.addFilter(filter.filterFromXml(xml.childNodes[i]));
-                }
-
-            }
-
-            return filterObj;
-        }
-
-    }
-    @sealed
-    export class linkEntity {
-        /**
-         * Contains the data for a fetchXml link-entity element.
-         * @param name The logical name of the entity
-         * @param from The from property of the linkEntity
-         * @param to The to property of the linkEntity
-         * @param linktype The linktype property of the linkEntity
-         * @param alias The alias property of the linkEntity
-         */
-        constructor(name: string, from?: string, to?: string, linktype?: string, alias?: string) {
-            if (!(this instanceof linkEntity))
-            { return new linkEntity(name, from, to, linktype, alias); }
-
-            this.name = name;
-            if (from)
-                this.from = from;
-            if (to)
-                this.to = to;
-            if (linktype)
-                this.linktype = linktype;
-            if (alias)
-                this.alias = alias;
-        }
-
-        private _name: string = null;
-        private _alias: string = null;
-        private _from: string = null;
-        private _intersect: boolean = null;
-        private _linktype: string = null;
-        private _to: string = null;
-        private _visible: boolean = null;
-        private _allAttributes: boolean = null;
-        private _attributes: Array<attribute> = [];
-        private _orders: Array<order> = [];
-        private _linkEntities: Array<linkEntity> = [];
-        private _filters: Array<filter> = [];
-
-        /**
-        *  Gets or sets the name property of the linkEntity
-        */
-        public get name(): string {
-            return this._name;
-        }
-        public set name(value: string) {
-            this._name = value;
-        }
-        /**
-        * Gets or sets the alias property of the linkEntity
-        */
-        public get alias(): string {
-            return this._alias;
-        }
-        public set alias(value: string) {
-            this._alias = value;
-        }
-        /**
-        * Gets or sets the from property of the linkEntity
-        */
-        public get from(): string {
-            return this._from;
-        }
-        public set from(value: string) {
-            this._from = value;
-        }
-        /**
-        * Gets or sets the intersect property of the linkEntity
-        */
-        public get intersect(): boolean {
-            return this._intersect;
-        }
-        public set intersect(value: boolean) {
-            this._intersect = value;
-        }
-        /**
-        * Gets or sets the linktype property of the linkEntity
-        */
-        public get linktype(): string {
-            return this._linktype;
-        }
-        public set linktype(value: string) {
-            this._linktype = value;
-        }
-        /**
-        * Gets or sets the to property of the linkEntity
-        */
-        public get to(): string {
-            return this._to;
-        }
-        public set to(value: string) {
-            this._to = value;
-        }
-        /**
-        * Gets or sets the visible property of the linkEntity
-        */
-        public get visible(): boolean {
-            return this._visible;
-        }
-        public set visible(value: boolean) {
-            this._visible = value;
-        }
-        /**
-        * Gets or sets the allAttributes property of the linkEntity
-        */
-        public get allAttributes(): boolean {
-            return this._allAttributes;
-        }
-        public set allAttributes(value: boolean) {
-            this._allAttributes = value;
-        }
-        /**
-        * Gets or sets the array of attribute of the entity to be returned in the query results
-        */
-        public get attributes(): Array<attribute> {
-            return this._attributes;
-        }
-        public set attributes(value: Array<attribute>) {
-            if (!Util.isAttributeArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.linkEntity.attributes must be an array of Sdk.FetchXml.attribute or null.");
-            }
-            if (value == null) {
-                this._attributes = [];
-            } else {
-                this._attributes = value;
-            }
-
-        }
-        /**
-        * Gets or sets the array of attribute of the entity to be returned in the query results
-        */
-        public get orders(): Array<order> {
-            return this._orders;
-        }
-        public set orders(value: Array<order>) {
-            if (!Util.isOrderArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.linkEntity.orders must be an array of Sdk.FetchXml.order or null.");
-            }
-            if (value == null) {
-                this._orders = [];
-            } else {
-                this._orders = value;
-            }
-
-        }
-        /**
-        * Gets or sets the array of linkEntity to be applied to the query results
-        */
-        public get linkEntities(): Array<linkEntity> {
-            return this._linkEntities;
-        }
-        public set linkEntities(value: Array<linkEntity>) {
-            if (!Util.isLinkEntityArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.linkEntity.linkEntities must be an array of Sdk.FetchXml.linkEntity or null.");
-            }
-            if (value == null) {
-                this._linkEntities = [];
-            } else {
-                this._linkEntities = value;
-            }
-        }
-        /**
-        * Gets or sets the array of filters to be applied to the query results
-        */
-        public get filters(): Array<filter> {
-            return this._filters;
-        }
-        public set filters(value: Array<filter>) {
-            if (!Util.isFilterArrayOrNull(value)) {
-                throw new Error("Sdk.FetchXml.linkEntity.filters must be an array of Sdk.FetchXml.filter or null.");
-            }
-            if (value == null) {
-                this._filters = [];
-            } else {
-                this._filters = value;
-            }
-
-        }
-        //Internal use only
-        public get hash(): string {
-            var s = this._name.concat(
-                (this._alias ? this._alias : ""),
-                (this._from ? this._from : ""),
-                (Util.isNullOrUndefined(this._intersect) ? "" : this._intersect.toString()),
-                (this._linktype ? this._linktype : ""),
-                (this._to ? this._to : ""),
-                (Util.isNullOrUndefined(this._visible) ? "" : this._visible.toString()),
-                (Util.isNullOrUndefined(this._allAttributes) ? "" : this._allAttributes.toString()),
-                (Util.getCollectionHash(this._attributes)),
-                (Util.getCollectionHash(this._orders)),
-                (Util.getCollectionHash(this._linkEntities)),
-                (Util.getCollectionHash(this._filters))
-            );
-            return s.hashCode();
-        }
-
-        /** @description Sets the alias property of the linkEntity attribute
-        * @param {string} alias The alias value to apply to the linkEntity
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public setAlias(alias) {
-            this.alias = alias;
-            return this;
-        }
-
-        /** @description Sets the from property of the linkEntity attribute
-        * @param {string} from The from value to apply to the linkEntity
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public setFrom(from) {
-            this.from = from;
-            return this;
-        }
-
-        /** @description Sets the intersect property of the linkEntity attribute
-        * @param {boolean | null} intersect The intersect value to apply to the linkEntity
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public setIntersect(intersect) {
-            this.intersect = intersect;
-            return this;
-        }
-
-        /** @description Sets the name property of the linkEntity attribute
-            * @param {string} name The name value to apply to the linkEntity
-            * @returns {Sdk.FetchXml.linkEntity}
-            */
-        public setName(name) {
-            this.name = name;
-            return this;
-        }
-
-        /** @description Sets the to property of the linkEntity attribute
-            * @param {string} to The to value to apply to the linkEntity
-            * @returns {Sdk.FetchXml.linkEntity}
-            */
-        public setTo(to) {
-            this.to = to;
-            return this;
-        }
-
-        /** @description Sets the visible property of the linkEntity attribute
-        * @param {boolean | null} visible The visible value to apply to the linkEntity
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public setVisible(visible) {
-            this.visible = visible;
-            return this;
-        }
-
-        /** @description Sets the allAttributes property of the linkEntity attribute
-        * @param {boolean} allAttributes The allAttributes value to apply to the linkEntity
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public setAllAttributes(allAttributes) {
-            this.allAttributes = allAttributes;
-            return this;
-        }
-
-        /** @description Adds an linkEntity to the linkEntities collection
-        * @param {Sdk.FetchXml.linkEntity} linkEntity The linkEntity to add to the linkEntities collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public addLinkEntity(linkEntity) {
-            if (Util.isLinkEntity(linkEntity)) {
-                this.linkEntities.push(linkEntity);
-                return this;
-            }
-            throw new Error("Sdk.FetchXml.linkEntity addLinkEntity method linkEntity parameter must be a Sdk.FetchXml.linkEntity value.");
-
-            return this;
-        }
-
-        /** @description Removes a linkEntity from the linkEntities collection by reference
-        * @param {Sdk.FetchXml.linkEntity} linkEntity The linkEntity to remove from the linkEntities collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeLinkEntityByRef(linkEntity) {
-            if (!Util.isLinkEntity(linkEntity)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeLinkEntityByRef method linkEntity parameter must be an Sdk.FetchXml.linkEntity.");
-            }
-            Util.removeCollectionValueByRef(this.linkEntities, linkEntity);
-
-            return this;
-        }
-
-        /** @description Removes a linkEntity from the linkEntities collection by value
-        * @param {Sdk.FetchXml.linkEntity} linkEntity The linkEntity to remove from the linkEntities collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeLinkEntity(linkEntity) {
-            if (!Util.isLinkEntity(linkEntity)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeLinkEntity method linkEntity parameter must be an Sdk.FetchXml.linkEntity.");
-            }
-            Util.removeCollectionValue(this.linkEntities, linkEntity);
-
-            return this;
-        }
-
-        /** @description Adds an attribute to the attributes collection
-        * @param {Sdk.FetchXml.attribute | string} attribute The attribute to add to the attributes collectio
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public addAttribute(attribute) {
-            if (Util.isAttribute(attribute)) {
-                this.attributes.push(attribute);
-                return this;
-            }
-            if (Util.isString(attribute)) {
-                this.attributes.push(new attribute(attribute));
-                return this;
-            }
-            throw new Error("Sdk.FetchXml.linkEntity addAttribute method attribute parameter must be a Sdk.FetchXml.attribute value or a string.");
-
-            return this;
-        }
-
-        /** @description Removes a attribute from the attributes collection by reference
-        * @param {Sdk.FetchXml.attribute} attribute The attribute to remove from the attributes collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeAttributeByRef(attribute) {
-            if (!Util.isAttribute(attribute)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeAttributeByRef method attribute parameter must be an Sdk.FetchXml.attribute.");
-            }
-            Util.removeCollectionValueByRef(this.attributes, attribute);
-
-            return this;
-        }
-
-        /** @description Removes a attribute from the attributes collection by value
-        * @param {Sdk.FetchXml.attribute} attribute The attribute to remove from the attributes collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeAttribute(attribute) {
-            if (!Util.isAttribute(attribute)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeAttribute method attribute parameter must be an Sdk.FetchXml.attribute.");
-            }
-            Util.removeCollectionValue(this.attributes, attribute);
-
-            return this;
-        }
-
-        /** @description Removes a attribute from the attributes collection by name
-        * @param {string} attributeName Name of the attribute to remove from the attributes collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeAttributeByName(attributeName) {
-            if (!Util.isString(attributeName)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeAttributeByName method attributeName parameter must be a string.");
-            }
-            Util.removeCollectionValueByProperty(this.attributes, "name", attributeName);
-            return this;
-        }
-
-        /** @description Adds an order to the orders collection
-        * @param {Sdk.FetchXml.order | string} orderOrAttribute The order to add to the attributes collection or the Attribute property of a new order to create
-        * @param {boolean} [descending] Whether the order is descending. True if descending, otherwise false
-        * @param {string} [alias] The alias to set for the order
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public addOrder(orderOrAttribute: any, descending?, alias?) {
-            if (Util.isOrder(orderOrAttribute)) {
-                this.orders.push(orderOrAttribute);
-                return this;
-            }
-            if (Util.isString(orderOrAttribute)) {
-                this.orders.push(new order(orderOrAttribute, descending, alias));
-                return this;
-            }
-            throw new Error("Sdk.FetchXml.linkEntity addOrder method orderOrAttribute parameter must be a Sdk.FetchXml.order value or a string.");
-
-            return this;
-        }
-
-        /** @description Removes a order from the orders collection by reference
-        * @param {Sdk.FetchXml.order} order The order to remove from the orders collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeOrderByRef(order) {
-            if (!Util.isOrder(order)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeOrderByRef method order parameter must be an Sdk.FetchXml.order.");
-            }
-            Util.removeCollectionValueByRef(this.orders, order);
-            return this;
-        }
-
-        /** @description Removes a order from the orders collection by value
-        * @param {Sdk.FetchXml.order} order The order to remove from the orders collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeOrder(order) {
-            if (!Util.isOrder(order)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeOrder method order parameter must be an Sdk.FetchXml.order.");
-            }
-            Util.removeCollectionValue(this.orders, order);
-            return this;
-        }
-
-        /** @description Adds an filter to the filters collection
-        * @param {Sdk.FetchXml.filter} filter The filter to add to the filters collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public addFilter(filter) {
-            if (Util.isFilter(filter)) {
-                this.filters.push(filter);
-                return this;
-            }
-
-            throw new Error("Sdk.FetchXml.linkEntity addFilter method filter parameter must be a Sdk.FetchXml.filter value.");
-
-            return this;
-        }
-
-        /** @description Removes a filter from the filters collection by reference
-        * @param {Sdk.FetchXml.filter} filter The filter to remove from the filters collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeFilterByRef(filter) {
-            if (!Util.isFilter(filter)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeFilterByRef method filter parameter must be an Sdk.FetchXml.filter.");
-            }
-            Util.removeCollectionValueByRef(this.filters, filter);
-
-            return this;
-        }
-
-        /** @description Removes a filter from the filters collection by value
-        * @param {Sdk.FetchXml.filter} filter The filter to remove from the filters collection
-        * @returns {Sdk.FetchXml.linkEntity}
-        */
-        public removeFilter(filter) {
-            if (!Util.isFilter(filter)) {
-                throw new Error("Sdk.FetchXml.linkEntity removeFilter method filter parameter must be an Sdk.FetchXml.filter.");
-            }
-            Util.removeCollectionValue(this.filters, filter);
-
-            return this;
-        }
-
-        //Internal use only
-        toXml(doc: XMLDocument): Node {
-
-            var leNode = doc.createElement("link-entity");
-            if (this.alias) {
-                leNode.setAttribute("alias", this.alias);
-            }
-            if (this.allAttributes) {
-                leNode.appendChild(doc.createElement("all-attributes"));
-            }
-            if (this.from) {
-                leNode.setAttribute("from", this.from);
-            }
-            if (Util.isBoolean(this.intersect)) {
-                leNode.setAttribute("intersect", this.intersect.toString());
-            }
-            if (this.linktype) {
-                leNode.setAttribute("link-type", this.linktype);
-            }
-            if (this.name) {
-                leNode.setAttribute("name", this.name);
-            }
-            if (this.to) {
-                leNode.setAttribute("to", this.to);
-            }
-            if (Util.isBoolean(this.visible)) {
-                leNode.setAttribute("visible", this.visible.toString());
-            }
-            this.attributes.forEach(function (a) {
-                leNode.appendChild(a.toXml(doc));
-            });
-            this.orders.forEach(function (o) {
-                leNode.appendChild(o.toXml(doc));
-            });
-            this.linkEntities.forEach(function (l) {
-                leNode.appendChild(l.toXml(doc));
-            });
-            this.filters.forEach(function (f) {
-                leNode.appendChild(f.toXml(doc));
-            });
-
-            return leNode;
-        }
-
-        static linkEntityFromXml(xml) {
-            var name = xml.attributes.getNamedItem("name").nodeValue;
-            var linkEntityObj = new linkEntity(name);
-            linkEntityObj.allAttributes = (xml.getElementsByTagName("all-attributes").length == 1);
-
-            Util.parseAttributes(xml, linkEntityObj, (linkEntityObj, name, value) => {
-                switch (name) {
-                    case "to":
-                    case "from":
-                    case "alias":
-                        linkEntityObj[name] = value;
-                        break;
-                    case "link-type":
-                        linkEntityObj.linktype = value;
-                        break;
-                    case "visible":
-                    case "intersect":
-                        linkEntityObj[name] = (value == "true") ? true : false;
-                        break;
-                    default:
-                        break;
-                }
-            });
-
-            for (var i = 0; i < xml.childNodes.length; i++) {
-
-                if (xml.childNodes[i].nodeName == "attribute") {
-                    linkEntityObj.addAttribute(attribute.attributeFromXml(xml.childNodes[i]));
-                }
-
-                if (xml.childNodes[i].nodeName == "order") {
-                    linkEntityObj.addOrder(order.orderFromXml(xml.childNodes[i]));
-                }
-
-                if (xml.childNodes[i].nodeName == "filter") {
-                    linkEntityObj.addFilter(filter.filterFromXml(xml.childNodes[i]));
-                }
-
-                if (xml.childNodes[i].nodeName == "link-entity") {
-                    linkEntityObj.addLinkEntity(linkEntity.linkEntityFromXml(xml.childNodes[i]));
-                }
-            }
-
-            return linkEntityObj;
-        }
-
-    }
-    @sealed
-    export class order {
-        /**
-         * Contains the data for a fetchXml order element.
-         * @param attribute The logical name of the attribute
-         * @param descending Whether the order is decending. Default is false
-         * @param alias The alias to apply to the order
-         */
-        constructor(attribute?: string, descending?: boolean, alias?: string) {
-            // new keyword not required in JS
-            if (!(this instanceof order))
-            { return new order(attribute, descending, alias); }
-
-            if (attribute)
-                this.attribute = attribute;
-            if (descending)
-                this.descending = descending;
-            if (alias)
-                this.alias = alias;
-        }
-
-        private _attribute: string = null;
-        private _descending: boolean = null;
-        private _alias: string = null;
-
-        /**
-        * Gets or sets logical name of the attribute
-        */
-        public get attribute(): string {
-            return this._attribute;
-        }
-        public set attribute(value: string) {
-            this._attribute = value;
-        }
-        /**
-        *Gets or sets whether the order is descending. Default is false
-        */
-        public get descending(): boolean {
-            return this._descending;
-        }
-        public set descending(value: boolean) {
-            this._descending = value;
-        }
-        /**
-        * Gets or sets the alias property of the order
-        */
-        public get alias(): string {
-            return this._alias;
-        }
-        public set alias(value: string) {
-            this._alias = value;
-        }
-        //Internal use only
-        public get hash(): string {
-            var s = "".concat(
-                (this._attribute ? this._attribute : ""),
-                (this._alias ? this._alias : ""),
-                this._descending.toString());
-            return s.hashCode();
-        }
-
-        /** @description Sets the attribute property of the order attribute
-        * @param {string} attribute The attribute value to apply to the order
-        * @returns {Sdk.FetchXml.order}
-        */
-        public setAttribute(attribute) {
-            this.attribute = attribute;
-            return this;
-        }
-
-        /** @description Sets the alias property of the order attribute
-        * @param {string} alias The alias value to apply to the order
-        * @returns {Sdk.FetchXml.order}
-        */
-        public setAlias(alias) {
-            this.alias = alias;
-            return this;
-        }
-
-        /** @description Sets the descending property of the order attribute
-           * @param {boolean | null} descending The descending value to apply to the order
-           * @returns {Sdk.FetchXml.order}
-           */
-        public setDescending(descending) {
-            this.descending = descending;
-            return this;
-        }
-
-        //Internal use only
-        toXml(doc: XMLDocument): Node {
-            var orderNode = doc.createElement("order");
-            if (this.attribute) {
-                orderNode.setAttribute("attribute", this.attribute);
-            }
-            if (this.alias) {
-                orderNode.setAttribute("alias", this.alias);
-            }
-            if (!Util.isNullOrUndefined(this.descending)) {
-                orderNode.setAttribute("descending", this.descending.toString());
-            }
-            return orderNode;
-        }
-
-        static orderFromXml(xml) {
-            var orderObj = new order();
-            Util.parseAttributes(xml, orderObj, (orderObj, name, value) => {
-                switch (name) {
-                    case "attribute":
-                        orderObj.attribute = value;
-                        break;
-                    case "alias":
-                        orderObj.alias = value;
-                        break;
-                    case "descending":
-                        orderObj.descending = (value == "true") ? true : false;
-                        break;
-                    default:
-                        break;
-                }
-            });
-            return orderObj;
-        }
-    }
-    @sealed
-    export class value {
-        /**
-         * Contains the data for a fetchXml value element.
-         * @param  value The the value of the value
-         * @param [uiname] The uiname for the value
-         * @param [uitype] The uitype for the value
-         */
-        constructor(value: any, uiname?: string, uitype?: string) {
-            //New keyword not required in JS
-            if (!(this instanceof Sdk.FetchXml.value))
-            { return new value(value, uiname, uitype); }
-
-            if (value)
-                this.value = value;
-            if (uiname)
-                this.uiname = uiname;
-            if (uitype)
-                this.uitype = uitype;
-        }
-
-        private _value: any = null;
-        private _uiname: string = null;
-        private _uitype: string = null;
-
-        /**
-       * Gets or sets the  value for the value.
-       */
-        public get value(): any {
-            return this._value;
-        }
-        public set value(value: any) {
-            this._value = value;
-        }
-        /**
-       * Gets or sets the uiname to apply to the value
-       */
-        public get uiname(): string {
-            return this._uiname;
-        }
-        public set uiname(value: string) {
-            this._uiname = value;
-        }
-        /**
-       * Gets or sets the uitype to apply to the value
-       */
-        public get uitype(): string {
-            return this._uitype;
-        }
-        public set uitype(value: string) {
-            this._uitype = value;
-        }
-
-        /** @description Sets the value to apply in the value
-        * @param {string} value The value to apply in the value
-        * @returns {Sdk.FetchXml.value}
-        */
-        public setValue(value) {
-            this.value = value;
-            return this;
-        }
-
-        /** @description Sets the uiname to apply in the value
-        * @param {string} uiname The uiname to apply in the value
-        * @returns {Sdk.FetchXml.value}
-        */
-        public setUIname(value) {
-            this.uiname = value;
-            return this;
-        }
-
-        /** @description Sets the uitype to apply in the value
-        * @param {string} uitype The uitype to apply in the value
-        * @returns {Sdk.FetchXml.value}
-        */
-        public setUItype(value) {
-            this.uitype = value;
-            return this;
-        }
-
-        //Internal use only
-        toXml(doc: XMLDocument): Node {
-
-            var vNode = doc.createElement("value");
-            if (this.uitype) {
-                vNode.setAttribute("uitype", this.uitype);
-            }
-            if (this.uiname) {
-                vNode.setAttribute("uiname", this.uiname);
-            }
-            vNode.appendChild(doc.createTextNode(this.value));
-            return vNode;
-        }
-
-        static valueFromXml(xml) {
-
-            var valueObj = new value(xml.textContent);
-            Util.parseAttributes(xml, valueObj, (object, name, value) => {
-                switch (name) {
-                    case "uiname":
-                    case "uitype":
-                        object[name] = value;
-                        break;
-                }
-            });
-
-            return valueObj;
-        }
-
-    }
-    export class Util {
-        public static isBoolean(obj) {
-            return (typeof obj === "boolean");
-        }
-        public static isBooleanOrNull(obj) {
-            return (Util.isNull(obj) || Util.isBoolean(obj));
-        }
-        public static isNumber(obj) {
-            return (typeof (obj) === "number");
-        }
-        public static isNumberOrNull(obj) {
-            return (Util.isNull(obj) || Util.isNumber(obj));
-        }
-        public static isNull(obj) {
-            return (obj === null);
-        }
-        public static isNullOrUndefined(obj) {
-            return (obj === null || typeof obj == "undefined");
-        }
-        public static isEnumMember(enumType, obj) {
-            for (var i in enumType) {
-                if (obj === enumType[i]) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        public static isEnumMemberOrNull(enumType, obj) {
-            return (Util.isNull(obj) || Util.isEnumMember(enumType, obj));
-        }
-        public static isString(obj) {
-            return (typeof obj === "string");
-        }
-        public static isStringOrNull(obj) {
-            return (Util.isNull(obj) || Util.isString(obj));
-        }
-        public static isOrder(obj) {
-            return (obj instanceof order);
-        }
-        public static isOrderOrNull(obj) {
-            return (Util.isNull(obj) || Util.isOrder(obj));
-        }
-        public static isOrderArray(obj) {
-            if (Array.isArray(obj)) {
-                obj.forEach(function (item) {
-                    if (!Util.isOrder(item)) {
-                        return false;
-                    }
-                });
-                return true;
-            }
-            return false;
-        }
-        public static isOrderArrayOrNull(obj) {
-            return (Util.isNull(obj) || Util.isOrderArray(obj));
-        }
-        public static isEntity(obj) {
-            return (obj instanceof entity);
-        }
-        public static isAttribute(obj) {
-            return (obj instanceof attribute);
-        }
-        public static isAttributeArray(obj) {
-            if (Array.isArray(obj)) {
-                obj.forEach(function (item) {
-                    if (!Util.isAttribute(item)) {
-                        return false;
-                    }
-                });
-                return true;
-            }
-            return false;
-        }
-        public static isAttributeArrayOrNull(obj) {
-            return (Util.isNull(obj) || Util.isAttributeArray(obj));
-        }
-        public static isLinkEntity(obj) {
-            return (obj instanceof linkEntity);
-        }
-        public static isLinkEntityOrNull(obj) {
-            return (Util.isNull(obj) || Util.isLinkEntity(obj));
-        }
-        public static isLinkEntityArray(obj) {
-            if (Array.isArray(obj)) {
-                obj.forEach(function (item) {
-                    if (!Util.isLinkEntity(item)) {
-                        return false;
-                    }
-                });
-                return true;
-            }
-            return false;
-        }
-        public static isLinkEntityArrayOrNull(obj) {
-            return (Util.isNull(obj) || Util.isLinkEntityArray(obj));
-        }
-        public static isFilter(obj) {
-            return (obj instanceof filter);
-        }
-        public static isFilterOrNull(obj) {
-            return (Util.isNull(obj) || Util.isFilter(obj));
-        }
-        public static isFilterArray(obj) {
-            if (Array.isArray(obj)) {
-                obj.forEach(function (item) {
-                    if (!Util.isFilter(item)) {
-                        return false;
-                    }
-                });
-                return true;
-            }
-            return false;
-        }
-        public static isFilterArrayOrNull(obj) {
-            return (Util.isNull(obj) || Util.isFilterArray(obj));
-        }
-        public static isCondition(obj) {
-            return (obj instanceof condition);
-        }
-        public static isConditionOrNull(obj) {
-            return (Util.isNull(obj) || Util.isCondition(obj));
-        }
-        public static isConditionArray(obj) {
-            if (Array.isArray(obj)) {
-                obj.forEach(function (item) {
-                    if (!Util.isCondition(item)) {
-                        return false;
-                    }
-                });
-                return true;
-            }
-            return false;
-        }
-        public static isConditionArrayOrNull(obj) {
-            return (Util.isNull(obj) || Util.isConditionArray(obj));
-        }
-        public static isValue(obj) {
-            return (obj instanceof value);
-        }
-        public static isValueOrNull(obj) {
-            return (Util.isNull(obj) || Util.isValue(obj));
-        }
-        public static isValueArray(obj) {
-            if (Array.isArray(obj)) {
-                var returnValue = true;
-                obj.forEach(function (item) {
-                    if (!Util.isValue(item)) {
-                        returnValue = false;
-                    }
-                });
-                return returnValue;
-            }
-            return false;
-        }
-        public static isValueArrayOrNull(obj) {
-            return (Util.isNull(obj) || Util.isValueArray(obj));
-        }
-        public static getEnumNameFromValue(enumtype, value) {
-            for (var i in enumtype) {
-                if (enumtype[i] == value) {
-                    return i;
-                }
-            }
-        }
-        public static getCollectionHash(collection) {
-            var ch = [];
-            collection.forEach(function (c) {
-                ch.push(c.hash);
-            });
-            return ch.join();
-        }
-        public static removeCollectionValue(collection, value) {
-            Util.removeCollectionValueByProperty(collection, "hash", value);
-        }
-        public static removeCollectionValueByProperty(collection, propertyName, value) {
-            var matches = [];
-            collection.forEach(function (b, i) {
-                //Check if same values
-                if (b[propertyName] == value[propertyName]) {
-                    matches.push(b);
-                }
-            });
-            matches.forEach(function (m) {
-                Util.removeCollectionValueByRef(collection, m);
-            });
-
-        }
-        public static removeCollectionValueByRef(collection, value) {
-            var indexes = [];
-            collection.forEach(function (a, i) {
-                //check if same object
-                if (a === value) {
-                    indexes.push(i);
-                }
-            });
-            if (indexes.length > 0) {
-                //Removing in reverse order
-                for (var i = indexes.length - 1; i >= 0; i--) {
-                    collection.splice(indexes[i], 1);
-                }
-            }
-        }
-        public static convertFetchBoolType(value) {
-            switch (value) {
-                case "true":
-                case "1":
-                    return true;
-                case "false":
-                case "0":
-                    return false;
-                default:
-                    throw new Error("Unexpected FetchBoolType value");
-                    break;
-            }
-        }
-        public static parseAttributes(xml: Node, object: Object, switchFunction: Function) {
-            var atts = xml.attributes;
-            for (var i = 0; i < atts.length; i++) {
-                var name = atts[i].nodeName;
-                var value = atts[i].nodeValue;
-                switchFunction(object, name, value);
-            }
-        }
-    }
-    @frozen
-    export class Mapping {
-        static Internal = "internal";
-        static Logical = "logical";
-    }
-    @frozen
-    export class OutputFormat {
-        static Ado = "xml-ado";
-        static Auto = "xml-auto";
-        static Elements = "xml-elements";
-        static Raw = "xml-raw";
-        static Platform = "xml-platform";
-    }
-    @frozen
-    export class Build {
-
-        static OnePoint504021 = "1.504021";
-        static OnePoint003017 = "1.003017";
-    }
-    @frozen
-    export class Aggregate {
-        static Count = "count";
-        static CountColumn = "countcolumn";
-        static Sum = "sum";
-        static Avg = "avg";
-        static Min = "min";
-        static Max = "max";
-    }
-    @frozen
-    export class RowAggregate {
-        static Countchildren = "countchildren";
-    }
-    @frozen
-    export class DateGrouping {
-        static Day = "day";
-        static Week = "week";
-        static Month = "month";
-        static Quarter = "quarter";
-        static Year = "year";
-        static FiscalPeriod = "fiscal-period";
-        static FiscalYear = "fiscal-year";
-    }
-    @frozen
-    export class Operator {
-        /** Returns all records in referenced record's hierarchical ancestry line.*/
-        static Above = "above";
-        /** The string occurs at the beginning of another string.*/
-        static BeginsWith = "begins-with";
-        /** The value is between two values.*/
-        static Between = "between";
-        /** The string ends with another string.*/
-        static EndsWith = "ends-with";
-        /** The values are compared for equality. */
-        static Equal = "eq";
-        /** The value is equal to the specified business ID. */
-        static EqualBusinessId = "eq-businessid";
-        /** Returns the referenced record and all records above it in the hierarchy.*/
-        static EqualOrAbove = "eq-or-above";
-        /** Returns the referenced record and all records below it in the hierarchy.*/
-        static EqualOrUnder = "eq-or-under";
-        /** The value is equal to the specified user ID.*/
-        static EqualUserId = "eq-userid";
-        /** The value is equal to the language for the user. */
-        static EqualUserLanguage = "eq-userlanguage";
-        /** When hierarchical security models are used; Equals current user or his reporting hierarchy*/
-        static EqualUserOrUserHierarchy = "eq-useroruserhierarchy";
-        /** When hierarchical security models are used; Equals current user and his teams or his reporting hierarchy and their teams*/
-        static EqualUserOrUserHierarchyAndTeams = "eq-useroruserhierarchyandteams";
-        /** The record is owned by a user or teams that the user is a member of.*/
-        static EqualUserOrUserTeams = "eq-useroruserteams";
-        /** The record is owned by teams that the user is a member of.*/
-        static EqualUserTeams = "eq-userteams";
-        /** The value is greater than or equal to the compared value.*/
-        static GreaterOrEqual = "ge";
-        /** The value is greater than the compared value.*/
-        static GreaterThan = "gt";
-        /** The value exists in a list of values.*/
-        static In = "in";
-        /** The value is within the specified fiscal period.*/
-        static InFiscalPeriod = "in-fiscal-period";
-        /** The value is within the specified fiscal period and year.*/
-        static InFiscalPeriodAndYear = "in-fiscal-period-and-year";
-        /** The value is within the specified year.*/
-        static InFiscalYear = "in-fiscal-year";
-        /** The value is within or after the specified fiscal period and year.*/
-        static InOrAfterFiscalPeriodAndYear = "in-or-after-fiscal-period-and-year";
-        /** The value is within or before the specified fiscal period and year.*/
-        static InOrBeforeFiscalPeriodAndYear = "in-or-before-fiscal-period-and-year";
-        /** The value is within the last fiscal period.*/
-        static LastFiscalPeriod = "last-fiscal-period";
-        /** The value is within the last fiscal year.*/
-        static LastFiscalYear = "last-fiscal-year";
-        /** The value is within the last month*/
-        static LastMonth = "last-month";
-        /** The value is within last seven days.*/
-        static LastSevenDays = "last-seven-days";
-        /** The value is within the previous week*/
-        static LastWeek = "last-week";
-        /** The value is within last X days.*/
-        static LastXDays = "last-x-days";
-        /** The value is within the last X fiscal periods.*/
-        static LastXFiscalPeriods = "last-x-fiscal-periods";
-        /** The value is within the last X fiscal years.*/
-        static LastXFiscalYears = "last-x-fiscal-years";
-        /** The value is within the last X hours.*/
-        static LastXHours = "last-x-hours";
-        /** The value is within the last X months.*/
-        static LastXMonths = "last-x-months";
-        /** The value is within the last X weeks.*/
-        static LastXWeeks = "last-x-weeks";
-        /** The value is within the last X years.*/
-        static LastXYears = "last-x-years";
-        /** The value is within the last year.*/
-        static LastYear = "last-year";
-        /** The value is less than or equal to the compared value.*/
-        static LessOrEqual = "le";
-        /** The character string is matched to the specified pattern.*/
-        static Like = "like";
-        /** The value is less than the compared value.*/
-        static LessThan = "lt";
-        /** The two values are not equal.*/
-        static NotEqual = "ne";
-        /** The value is not equal to the specified business ID.*/
-        static NotEqualBusinessId = "ne-businessid";
-        /** The value is not equal to the specified user ID.*/
-        static NotEqualUserId = "ne-userid";
-        /** Not Equal To*/
-        static Neq = "neq"; //Is this the same as 'ne'?
-        /** The value is within the next fiscal period.*/
-        static NextFiscalPeriod = "next-fiscal-period";
-        /** The value is within the next fiscal year.*/
-        static NextFiscalYear = "next-fiscal-year";
-        /** The value is within the next month.*/
-        static NextMonth = "next-month";
-        /** The value is within the next seven days.*/
-        static NextSevenDays = "next-seven-days";
-        /** The value is within the next week.*/
-        static NextWeek = "next-week";
-        /** The value is within the X days.*/
-        static NextXDays = "next-x-days";
-        /** The value is within the next X fiscal periods.*/
-        static NextXFiscalPeriods = "next-x-fiscal-periods";
-        /** The value is within the next X fiscal years.*/
-        static NextXFiscalYears = "next-x-fiscal-years";
-        /** The value is within the next X hours.*/
-        static NextXHours = "next-x-hours";
-        /** The value is within the next X nonths.*/
-        static NextXMonths = "next-x-months";
-        /** The value is within the next X weeks.*/
-        static NextXWeeks = "next-x-weeks";
-        /** The value is within the next X years.*/
-        static NextXYears = "next-x-years";
-        /** The value is within the next year.*/
-        static NextYear = "next-year";
-        /** The string does not begin with another string.*/
-        static NotBeginWith = "not-begin-with";
-        /** The value is not between two values.*/
-        static NotBetween = "not-between";
-        /** The string does not end with another string.*/
-        static NotEndWith = "not-end-with";
-        /** The given value is not matched to a value in a subquery or a list.*/
-        static NotIn = "not-in";
-        /** The character string does not match the specified pattern.*/
-        static NotLike = "not-like";
-        /** The value is not null.*/
-        static NotNull = "not-null";
-        /** Returns all records not below the referenced record in the hierarchy*/
-        static NotUnder = "not-under";
-        /** The value is null.*/
-        static Null = "null";
-        /** The value is older than the specified number of days. */
-        static OlderThanXDays = "olderthan-x-days";
-        /** The value is older than the specified number of hours. */
-        static OlderThanXHours = "olderthan-x-hours";
-        /** The value is older than the specified number of minutes. */
-        static OlderThanXMinutes = "olderthan-x-minutes";
-        /** The value is older than the specified number of months. */
-        static OlderThanXMonths = "olderthan-x-months";
-        /** The value is older than the specified number of weeks. */
-        static OlderThanXWeeks = "olderthan-x-weeks";
-        /** The value is older than the specified number of years. */
-        static OlderThanXYears = "olderthan-x-years";
-        /** 	The value is on a specified date.*/
-        static On = "on";
-        /** The value is on or after a specified date.*/
-        static OnOrAfter = "on-or-after";
-        /** The value is on or before a specified date.*/
-        static OnOrBefore = "on-or-before";
-        /** 	The value is within the current fiscal period.*/
-        static ThisFiscalPeriod = "this-fiscal-period";
-        /** The value is within the current fiscal year.*/
-        static ThisFiscalYear = "this-fiscal-year";
-        /** The value is within the current month.*/
-        static ThisMonth = "this-month";
-        /** The value is within the current week.*/
-        static ThisWeek = "this-week";
-        /** 	The value is within the current year.*/
-        static ThisYear = "this-year";
-        /** The value equals today’s date.*/
-        static Today = "today";
-        /** The value equals tomorrow’s date.*/
-        static Tomorrow = "tomorrow";
-        /** Returns all child records below the referenced record in the hierarchy*/
-        static Under = "under";
-        /** The value equals yesterday’s date.*/
-        static Yesterday = "yesterday";
-    }
-    @frozen
-    export class FilterType {
-        static And = "and";
-        static Or = "or";
-    }
-}
-
-function sealed(constructor: Function) {
-    Object.seal(constructor);
-    Object.seal(constructor.prototype);
-}
-function frozen(constructor: Function) {
-    Object.freeze(constructor);
-    Object.freeze(constructor.prototype);
-}
-
-/*
-Hash Generator modified from
-http://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript-jquery
-http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
-*/
-
-interface String {
-    hashCode: () => string;
-}
-
-String.prototype.hashCode = function (): string {
-    let hash = 0;
-    if (this.length == 0) return hash.toString();
-    for (let i = 0; i < this.length; i++) {
-        let char = this.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return hash.toString();
-};