angular-odata 0.99.2 → 0.100.1

package/fesm2020/angular-odata.mjs

@@ -33,6 +33,7 @@ var QueryOptionNames;
     QueryOptionNames["skip"] = "skip";
     QueryOptionNames["skiptoken"] = "skiptoken";
     QueryOptionNames["format"] = "format";
+    QueryOptionNames["levels"] = "levels";
     QueryOptionNames["count"] = "count";
 })(QueryOptionNames || (QueryOptionNames = {}));
 const NONE_PARSER = {
@@ -213,7 +214,7 @@ class ODataCache {
                 return of(cached);
             }
             else {
-                return throwError('No Cached');
+                return throwError(() => new Error('No Cached'));
             }
         }
         if (policy === 'cache-first' ||
@@ -390,7 +391,7 @@ function buildPathAndQuery({ select, search, skiptoken, format, top, skip, filte
     }
     if (func) {
         if (typeof func === 'string') {
-            path += `/${func}`;
+            path += `/${func}()`;
         }
         else if (typeof func === 'object') {
             const [funcName] = Object.keys(func);
@@ -398,10 +399,7 @@ function buildPathAndQuery({ select, search, skiptoken, format, top, skip, filte
                 aliases,
                 escape,
             });
-            path += `/${funcName}`;
-            if (funcArgs !== '') {
-                path += `(${funcArgs})`;
-            }
+            path += `/${funcName}(${funcArgs})`;
         }
     }
     if (aliases.length > 0) {
@@ -650,7 +648,7 @@ function escapeIllegalChars(string) {
     string = string.replace(/'/g, "''");
     return string;
 }
-function normalizeValue(value, { aliases, escape = false }) {
+function normalizeValue(value, { aliases, escape = false, } = {}) {
     if (typeof value === 'string') {
         return escape ? `'${escapeIllegalChars(value)}'` : `'${value}'`;
     }
@@ -745,6 +743,7 @@ function buildExpand(expands, { aliases, escape = false }) {
                     case 'levels':
                     case 'count':
                     case 'top':
+                    case 'skip':
                         value = `${expands[key]}`;
                         break;
                     default:
@@ -1331,6 +1330,10 @@ const Objects = {
         if (typeof target != 'object' || target == null) {
             return target;
         }
+        if (Types.isObject(target) && 'clone' in target) {
+            // target is a cloneable object
+            return target.clone();
+        }
         const type = Types.rawType(target);
         let cloneTarget = null;
         if (map.get(target)) {
@@ -1420,7 +1423,7 @@ const Urls = {
             let index = param.indexOf(VALUE_SEPARATOR);
             if (index !== -1)
                 Object.assign(acc, {
-                    [param.substr(0, index)]: param.substr(index + 1),
+                    [param.substring(0, index)]: param.substring(index + 1),
                 });
             return acc;
         }, {});
@@ -1461,17 +1464,33 @@ class Field$1 {
     constructor(name = '') {
         this.name = name;
     }
-    static factory() {
-        const h = new Field$1();
-        return new Proxy({ _name: '' }, h);
+    static factory(name = '') {
+        return new Proxy({ _name: name }, new Field$1());
     }
-    get(target, p) {
+    get(target, key) {
         let name = target['_name'];
-        if (p === 'render') {
+        if (key === 'render') {
             return ({ prefix }) => prefix ? `${prefix}/${name}` : name;
         }
-        name = name ? `${name}/${p}` : p;
-        return new Proxy({ _name: name }, this);
+        else if (key === 'clone') {
+            return () => Field$1.factory(name);
+        }
+        else if (key === Symbol.toStringTag) {
+            return () => 'Field';
+        }
+        else if (key === 'toJSON') {
+            return () => ({
+                $type: Types.rawType(this),
+                name: name,
+            });
+        }
+        else {
+            name = name ? `${name}/${key}` : key;
+            return new Proxy({ _name: name }, this);
+        }
+    }
+    has(target, key) {
+        return ['toJSON', 'clone', 'render'].includes(key) || key in target;
     }
 }
 function applyMixins(derivedCtor, constructors) {
@@ -1510,6 +1529,7 @@ class Function {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             name: this.name,
             values: this.values,
             normalize: this.normalize,
@@ -1518,12 +1538,15 @@ class Function {
     render({ aliases, escape, prefix, }) {
         let [field, ...values] = this.values;
         field = render(field, { aliases, escape, prefix });
-        let params = [
+        const params = [
             field,
             ...values.map((v) => render(v, { aliases, escape, prefix, normalize: this.normalize })),
         ];
         return `${this.name}(${params.join(', ')})`;
     }
+    clone() {
+        return new Function(this.name, this.values.map((v) => Objects.clone(v)), this.normalize, this.escape);
+    }
 }
 class StringAndCollectionFunctions {
     concat(field, value, normalize) {
@@ -1664,6 +1687,7 @@ class Operator {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             op: this.op,
             values: this.values,
             normalize: this.normalize,
@@ -1692,6 +1716,9 @@ class Operator {
         }
         return `${this.op}(${left})`;
     }
+    clone() {
+        return new Operator(this.op, this.values.map((v) => Objects.clone(v)), this.normalize);
+    }
 }
 class LogicalOperators {
     eq(left, right, normalize) {
@@ -1759,12 +1786,16 @@ class Grouping {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             group: this.group.toJSON(),
         };
     }
     render({ aliases, escape, prefix, }) {
         return `(${render(this.group, { aliases, escape, prefix })})`;
     }
+    clone() {
+        return new Grouping(Objects.clone(this.group));
+    }
 }
 class Lambda {
     constructor(op, values, alias) {
@@ -1777,6 +1808,7 @@ class Lambda {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             op: this.op,
             values: this.values,
             alias: this.alias,
@@ -1792,6 +1824,9 @@ class Lambda {
             prefix: alias,
         })})`;
     }
+    clone() {
+        return new Lambda(this.op, this.values.map((v) => Objects.clone(v)), this.alias);
+    }
 }
 class LambdaOperators {
     any(field, value, alias) {
@@ -1838,16 +1873,23 @@ class ComputeExpression extends Expression {
     static s() {
         return Field$1.factory();
     }
-    static compute(opts) {
+    static compute(opts, current) {
         return opts({
             s: ComputeExpression.s(),
             e: ComputeExpression.e,
-        });
+        }, current);
     }
     render({ aliases, escape, prefix, } = {}) {
-        let children = this._children
-            .map((n) => n.render({ aliases, escape, prefix }));
-        return this.names.map((name, index) => `${children[index]} as ${name}`).join(',');
+        let children = this._children.map((n) => n.render({ aliases, escape, prefix }));
+        return this.names
+            .map((name, index) => `${children[index]} as ${name}`)
+            .join(',');
+    }
+    clone() {
+        return new ComputeExpression({
+            children: this._children.map((c) => c.clone()),
+            names: [...this.names],
+        });
     }
     _add(name, node) {
         this.names.push(name);
@@ -1875,13 +1917,13 @@ class FilterExpression extends Expression {
     static e(connector = 'and') {
         return new FilterExpression({ connector });
     }
-    static filter(opts) {
+    static filter(opts, current) {
         return opts({
             s: FilterExpression.s(),
             e: FilterExpression.e,
             o: operators,
             f: functions,
-        });
+        }, current);
     }
     toJSON() {
         return {
@@ -1905,6 +1947,13 @@ class FilterExpression extends Expression {
         }
         return content;
     }
+    clone() {
+        return new FilterExpression({
+            children: this._children.map((c) => c.clone()),
+            connector: this._connector,
+            negated: this._negated,
+        });
+    }
     _add(node, connector) {
         if (connector !== undefined && this._connector !== connector) {
             let children = [];
@@ -2031,6 +2080,9 @@ class OrderByField {
     render({ aliases, escape, prefix, }) {
         return `${render(this.field, { aliases, escape, prefix })} ${this.order}`;
     }
+    clone() {
+        return new OrderByField(this.field.clone(), this.order);
+    }
 }
 class OrderByExpression extends Expression {
     constructor({ children, } = {}) {
@@ -2042,11 +2094,11 @@ class OrderByExpression extends Expression {
     static s() {
         return Field$1.factory();
     }
-    static orderBy(opts) {
+    static orderBy(opts, current) {
         return opts({
             s: OrderByExpression.s(),
             e: OrderByExpression.e,
-        });
+        }, current);
     }
     _add(node) {
         this._children.push(node);
@@ -2058,6 +2110,11 @@ class OrderByExpression extends Expression {
             .join(`,`);
         return content;
     }
+    clone() {
+        return new OrderByExpression({
+            children: this._children.map((c) => c.clone()),
+        });
+    }
     ascending(field) {
         return this._add(new OrderByField(field, 'asc'));
     }
@@ -2075,12 +2132,16 @@ class SearchTerm {
     }
     toJSON() {
         return {
+            $type: Types.rawType(this),
             value: this.value,
         };
     }
     render({ aliases, escape, prefix, }) {
         return `${render(this.value, { aliases, escape, prefix })}`;
     }
+    clone() {
+        return new SearchTerm(this.value);
+    }
 }
 class SearchExpression extends Expression {
     constructor({ children, connector, negated, } = {}) {
@@ -2091,10 +2152,10 @@ class SearchExpression extends Expression {
     static e(connector = 'AND') {
         return new SearchExpression({ connector });
     }
-    static search(opts) {
+    static search(opts, current) {
         return opts({
             e: SearchExpression.e,
-        });
+        }, current);
     }
     _add(node, connector) {
         if (connector !== undefined && this._connector !== connector) {
@@ -2145,6 +2206,13 @@ class SearchExpression extends Expression {
             .join(` ${this._connector} `);
         return content;
     }
+    clone() {
+        return new SearchExpression({
+            children: this._children.map((c) => c.clone()),
+            connector: this._connector,
+            negated: this._negated,
+        });
+    }
     toJSON() {
         return {
             children: this._children.map((c) => c.toJSON()),
@@ -2177,9 +2245,45 @@ class SearchExpression extends Expression {
     }
 }
 
+class SelectExpression extends Expression {
+    constructor({ children, } = {}) {
+        super({ children });
+    }
+    static e() {
+        return new SelectExpression();
+    }
+    static s() {
+        return Field$1.factory();
+    }
+    static select(builder, current) {
+        return builder({
+            s: SelectExpression.s(),
+            e: SelectExpression.e,
+        }, current);
+    }
+    render({ aliases, escape, prefix, } = {}) {
+        return this._children
+            .map((n) => n.render({ aliases, escape, prefix }))
+            .join(',');
+    }
+    clone() {
+        return new SelectExpression({
+            children: this._children.map((c) => c.clone()),
+        });
+    }
+    _add(node) {
+        this._children.push(node);
+        return this;
+    }
+    field(field) {
+        return this._add(field);
+    }
+}
+
 class ExpandField {
-    constructor(field) {
+    constructor(field, values = {}) {
         this.field = field;
+        this.values = values;
     }
     get [Symbol.toStringTag]() {
         return 'ExpandField';
@@ -2190,14 +2294,66 @@ class ExpandField {
         };
     }
     render({ aliases, escape, prefix, }) {
-        return `${render(this.field, { aliases, escape, prefix })}`;
+        const params = [
+            QueryOptionNames.select,
+            QueryOptionNames.expand,
+            QueryOptionNames.filter,
+            QueryOptionNames.search,
+            QueryOptionNames.orderBy,
+            QueryOptionNames.skip,
+            QueryOptionNames.top,
+            QueryOptionNames.levels,
+        ]
+            .filter((key) => !Types.isEmpty(this.values[key]))
+            .reduce((acc, key) => {
+            let value = this.values[key];
+            if (Types.rawType(value).endsWith('Expression')) {
+                value = value.render({ aliases, prefix, escape });
+            }
+            return Object.assign(acc, { [key]: value });
+        }, {});
+        let expand = `${render(this.field, { aliases, escape, prefix })}`;
+        if (!Types.isEmpty(params)) {
+            expand = `${expand}(${Object.keys(params)
+                .map((key) => `$${key}=${params[key]}`)
+                .join(';')})`;
+        }
+        return expand;
+    }
+    clone() {
+        const values = Object.keys(this.values).reduce((acc, key) => Object.assign(acc, { [key]: Objects.clone(this.values[key]) }), {});
+        return new ExpandField(this.field.clone(), values);
+    }
+    select(opts) {
+        return this.option(QueryOptionNames.select, SelectExpression.select(opts, this.values[QueryOptionNames.select]));
+    }
+    expand(opts) {
+        return this.option(QueryOptionNames.expand, ExpandExpression.expand(opts, this.values[QueryOptionNames.expand]));
+    }
+    filter(opts) {
+        return this.option(QueryOptionNames.filter, FilterExpression.filter(opts, this.values[QueryOptionNames.filter]));
+    }
+    search(opts) {
+        return this.option(QueryOptionNames.search, SearchExpression.search(opts, this.values[QueryOptionNames.search]));
+    }
+    orderBy(opts) {
+        return this.option(QueryOptionNames.orderBy, OrderByExpression.orderBy(opts, this.values[QueryOptionNames.orderBy]));
+    }
+    skip(n) {
+        return this.option(QueryOptionNames.skip, n);
+    }
+    top(n) {
+        return this.option(QueryOptionNames.top, n);
+    }
+    levels(n) {
+        return this.option(QueryOptionNames.levels, n);
+    }
+    // Option Handler
+    option(name, opts) {
+        if (opts !== undefined)
+            this.values[name] = opts;
+        return this.values[name];
     }
-    select() { }
-    filter() { }
-    levels() { }
-    orderBy() { }
-    top() { }
-    skip() { }
 }
 class ExpandExpression extends Expression {
     constructor({ children, } = {}) {
@@ -2209,17 +2365,22 @@ class ExpandExpression extends Expression {
     static s() {
         return Field$1.factory();
     }
-    static expand(opts) {
+    static expand(opts, current) {
         return opts({
             s: ExpandExpression.s(),
             e: ExpandExpression.e,
-        });
+        }, current);
     }
     render({ aliases, escape, prefix, } = {}) {
         return this._children
             .map((n) => n.render({ aliases, escape, prefix }))
             .join(',');
     }
+    clone() {
+        return new ExpandExpression({
+            children: this._children.map((c) => c.clone()),
+        });
+    }
     _add(node) {
         this._children.push(node);
         return this;
@@ -2232,36 +2393,6 @@ class ExpandExpression extends Expression {
     }
 }
 
-class SelectExpression extends Expression {
-    constructor({ children, } = {}) {
-        super({ children });
-    }
-    static e() {
-        return new SelectExpression();
-    }
-    static s() {
-        return Field$1.factory();
-    }
-    static select(opts) {
-        return opts({
-            s: SelectExpression.s(),
-            e: SelectExpression.e,
-        });
-    }
-    render({ aliases, escape, prefix, } = {}) {
-        return this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
-            .join(',');
-    }
-    _add(node) {
-        this._children.push(node);
-        return this;
-    }
-    field(field) {
-        return this._add(field);
-    }
-}
-
 class ODataQueryOptionHandler {
     constructor(o, n) {
         this.o = o;
@@ -2271,30 +2402,32 @@ class ODataQueryOptionHandler {
         return this.n;
     }
     toJSON() {
-        return this.o[this.n];
+        return this.o.get(this.n);
     }
     empty() {
-        return Types.isEmpty(this.o[this.n]);
+        return Types.isEmpty(this.o.get(this.n));
     }
     //#region Primitive Value
     value(v) {
-        return (v !== undefined && (this.o[this.n] = v)) || this.o[this.n];
+        if (v !== undefined)
+            this.o.set(this.n, v);
+        return this.o.get(this.n);
     }
     //#endregion
     //#region Array Value
     assertArray() {
-        if (!Types.isArray(this.o[this.n]))
-            this.o[this.n] = this.o[this.n] !== undefined ? [this.o[this.n]] : [];
-        return this.o[this.n];
+        if (!Types.isArray(this.o.get(this.n)))
+            this.o.set(this.n, this.o.has(this.n) ? [this.o.get(this.n)] : []);
+        return this.o.get(this.n);
     }
     push(value) {
         this.assertArray().push(value);
     }
     remove(value) {
-        this.o[this.n] = this.assertArray().filter((v) => v !== value);
+        this.o.set(this.n, this.assertArray().filter((v) => v !== value));
         // If only one... down to value
-        if (this.o[this.n].length === 1)
-            this.o[this.n] = this.o[this.n][0];
+        if (this.o.get(this.n).length === 1)
+            this.o.set(this.n, this.o.get(this.n)[0]);
     }
     at(index) {
         return this.assertArray()[index];
@@ -2302,8 +2435,9 @@ class ODataQueryOptionHandler {
     //#endregion
     //#region HashMap Value
     assertObject(create) {
-        if (!Types.isArray(this.o[this.n]) && Types.isPlainObject(this.o[this.n])) {
-            return this.o[this.n];
+        if (!Types.isArray(this.o.get(this.n)) &&
+            Types.isPlainObject(this.o.get(this.n))) {
+            return this.o.get(this.n);
         }
         let arr = this.assertArray();
         let obj = arr.find((v) => Types.isPlainObject(v));
@@ -2324,10 +2458,10 @@ class ODataQueryOptionHandler {
     unset(path) {
         let obj = this.assertObject(true);
         Objects.unset(obj, path);
-        if (Types.isArray(this.o[this.n])) {
-            this.o[this.n] = this.o[this.n].filter((v) => !Types.isEmpty(v));
-            if (this.o[this.n].length === 1)
-                this.o[this.n] = this.o[this.n][0];
+        if (Types.isArray(this.o.get(this.n))) {
+            this.o.set(this.n, this.o.get(this.n).filter((v) => !Types.isEmpty(v)));
+            if (this.o.get(this.n).length === 1)
+                this.o.set(this.n, this.o.get(this.n)[0]);
         }
     }
     has(path) {
@@ -2340,7 +2474,7 @@ class ODataQueryOptionHandler {
     }
     //#endregion
     clear() {
-        delete this.o[this.n];
+        this.o.delete(this.n);
     }
 }
 class ODataQueryOptionsHandler {
@@ -2357,21 +2491,29 @@ class ODataQueryOptionsHandler {
     alias(value, name) {
         return alias(value, name);
     }
+    /**
+     * Normalize the given value to a valid odata value
+     * @param value The value to normalize
+     * @returns The normalized value
+     */
+    normalize(value) {
+        return normalizeValue(value);
+    }
     select(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.select, SelectExpression.select(opts));
+            return this.options.expression(QueryOptionNames.select, SelectExpression.select(opts, this.options.expression(QueryOptionNames.select)));
         }
         return this.options.option(QueryOptionNames.select, opts);
     }
     expand(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.expand, ExpandExpression.expand(opts));
+            return this.options.expression(QueryOptionNames.expand, ExpandExpression.expand(opts, this.options.expression(QueryOptionNames.expand)));
         }
         return this.options.option(QueryOptionNames.expand, opts);
     }
     compute(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.compute, ComputeExpression.compute(opts));
+            return this.options.expression(QueryOptionNames.compute, ComputeExpression.compute(opts, this.options.expression(QueryOptionNames.compute)));
         }
         return this.options.option(QueryOptionNames.compute, opts);
     }
@@ -2383,19 +2525,19 @@ class ODataQueryOptionsHandler {
     }
     search(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.search, SearchExpression.search(opts));
+            return this.options.expression(QueryOptionNames.search, SearchExpression.search(opts, this.options.expression(QueryOptionNames.search)));
         }
         return this.options.option(QueryOptionNames.search, opts);
     }
     filter(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.filter, FilterExpression.filter(opts));
+            return this.options.expression(QueryOptionNames.filter, FilterExpression.filter(opts, this.options.expression(QueryOptionNames.filter)));
         }
         return this.options.option(QueryOptionNames.filter, opts);
     }
     orderBy(opts) {
         if (Types.isFunction(opts)) {
-            return this.options.expression(QueryOptionNames.orderBy, OrderByExpression.orderBy(opts));
+            return this.options.option(QueryOptionNames.orderBy, OrderByExpression.orderBy(opts, this.options.expression(QueryOptionNames.orderBy)));
         }
         return this.options.option(QueryOptionNames.orderBy, opts);
     }
@@ -2423,30 +2565,33 @@ class ODataQueryOptionsHandler {
     }
     apply(query) {
         if (query.select !== undefined) {
-            this.select(query.select);
+            this.options.option(QueryOptionNames.select, query.select);
         }
         if (query.expand !== undefined) {
-            this.expand(query.expand);
+            this.options.option(QueryOptionNames.expand, query.expand);
         }
         if (query.transform !== undefined) {
-            this.transform(query.transform);
+            this.options.option(QueryOptionNames.transform, query.transform);
         }
         if (query.search !== undefined) {
-            this.search(query.search);
+            this.options.option(QueryOptionNames.search, query.search);
         }
         if (query.filter !== undefined) {
-            this.filter(query.filter);
+            this.options.option(QueryOptionNames.filter, query.filter);
         }
         if (query.orderBy !== undefined) {
-            this.orderBy(query.orderBy);
+            this.options.option(QueryOptionNames.orderBy, query.orderBy);
         }
         this.paging(query);
     }
 }
 
 class ODataQueryOptions {
-    constructor(options) {
-        this.options = options || {};
+    constructor(values) {
+        this.values =
+            values instanceof Map
+                ? values
+                : new Map(Object.entries(values || {}));
     }
     // Params
     pathAndParams(escape = false) {
@@ -2464,11 +2609,11 @@ class ODataQueryOptions {
             QueryOptionNames.expand,
             QueryOptionNames.format,
         ]
-            .filter((key) => !Types.isEmpty(this.options[key]))
+            .filter((key) => !Types.isEmpty(this.values.get(key)))
             .reduce((acc, key) => {
-            let value = this.options[key];
-            if (Types.rawType(value) === 'Expression') {
-                value = value.render(aliases);
+            let value = this.values.get(key);
+            if (Types.rawType(value).endsWith('Expression')) {
+                value = value.render({ aliases });
             }
             return Object.assign(acc, { [key]: value });
         }, {});
@@ -2483,63 +2628,63 @@ class ODataQueryOptions {
                 .join('&'));
     }
     toJSON() {
-        return Object.keys(this.options).reduce((acc, key) => {
-            let value = this.options[key];
-            if (Types.rawType(value) === 'Expression') {
-                value = value.toJSON();
-            }
+        return [...this.values.keys()].reduce((acc, key) => {
+            let value = this.values.get(key);
+            value =
+                Types.isObject(value) && 'toJSON' in value ? value.toJSON() : value;
             return Object.assign(acc, { [key]: value });
         }, {});
     }
     toQueryArguments() {
         return {
-            select: this.options[QueryOptionNames.select],
-            expand: this.options[QueryOptionNames.expand],
-            transform: this.options[QueryOptionNames.transform],
-            compute: this.options[QueryOptionNames.compute],
-            search: this.options[QueryOptionNames.search],
-            filter: this.options[QueryOptionNames.filter],
-            orderBy: this.options[QueryOptionNames.orderBy],
-            top: this.options[QueryOptionNames.top],
-            skip: this.options[QueryOptionNames.skip],
-            skiptoken: this.options[QueryOptionNames.skiptoken],
+            select: this.values.get(QueryOptionNames.select),
+            expand: this.values.get(QueryOptionNames.expand),
+            transform: this.values.get(QueryOptionNames.transform),
+            compute: this.values.get(QueryOptionNames.compute),
+            search: this.values.get(QueryOptionNames.search),
+            filter: this.values.get(QueryOptionNames.filter),
+            orderBy: this.values.get(QueryOptionNames.orderBy),
+            top: this.values.get(QueryOptionNames.top),
+            skip: this.values.get(QueryOptionNames.skip),
+            skiptoken: this.values.get(QueryOptionNames.skiptoken),
         };
     }
     clone() {
-        const options = Object.keys(this.options).reduce((acc, key) => {
-            let value = this.options[key];
-            if (Types.rawType(value) !== 'Expression') {
-                value = Objects.clone(value);
-            }
-            return Object.assign(acc, { [key]: value });
-        }, {});
-        return new ODataQueryOptions(options);
+        return new ODataQueryOptions(Objects.clone(this.values));
     }
     // Set Renderable
-    expression(name, exp) {
-        return (this.options[name] = exp);
+    expression(key, exp) {
+        if (exp !== undefined)
+            this.values.set(key, exp);
+        return this.values.get(key);
     }
     // Option Handler
-    option(name, opts) {
+    option(key, opts) {
         if (opts !== undefined)
-            this.options[name] = opts;
-        return new ODataQueryOptionHandler(this.options, name);
+            this.values.set(key, opts);
+        return new ODataQueryOptionHandler(this.values, key);
     }
     // Query Options tools
-    has(name) {
-        return this.options[name] !== undefined;
-    }
-    remove(...names) {
-        names.forEach((name) => this.option(name).clear());
+    has(key) {
+        return this.values.has(key);
+    }
+    remove(...keys) {
+        [...this.values.keys()]
+            .filter((k) => keys.indexOf(k) !== -1)
+            .forEach((key) => {
+            this.values.delete(key);
+        });
     }
-    keep(...names) {
-        this.options = Object.keys(this.options)
-            .filter((k) => names.indexOf(k) !== -1)
-            .reduce((acc, k) => Object.assign(acc, { [k]: this.options[k] }), {});
+    keep(...keys) {
+        [...this.values.keys()]
+            .filter((k) => keys.indexOf(k) === -1)
+            .forEach((key) => {
+            this.values.delete(key);
+        });
     }
     // Clear
     clear() {
-        this.options = {};
+        this.values.clear();
     }
 }
 
@@ -3141,70 +3286,69 @@ const ODataVersionBaseHelper = {
     property(data) {
         return this.VALUE in data ? data[this.VALUE] : data;
     },
-    functions(value) {
-        return Object.keys(value)
-            .filter((k) => k.startsWith(this.ODATA_FUNCTION_PREFIX))
-            .reduce((acc, key) => Object.assign(acc, { [key.substr(1)]: value[key] }), {});
+    functions(annots) {
+        const funcs = new Map();
+        [...annots.keys()]
+            .filter((key) => key.startsWith(this.ODATA_FUNCTION_PREFIX))
+            .forEach((key) => funcs.set(key.substring(this.ODATA_FUNCTION_PREFIX.length), annots.get(key)));
+        return funcs;
     },
-    properties(value) {
-        return Object.keys(value)
-            .filter((k) => k.indexOf(this.ODATA_ANNOTATION_PREFIX) > 0)
-            .reduce((acc, key) => {
-            let name = key.substr(0, key.indexOf(this.ODATA_ANNOTATION_PREFIX));
-            if (!(name in acc)) {
-                acc[name] = {};
-            }
-            Object.assign(acc[name], {
-                [key.substr(key.indexOf(this.ODATA_ANNOTATION_PREFIX))]: value[key],
-            });
-            return acc;
-        }, {});
+    properties(annots) {
+        const props = new Map();
+        [...annots.keys()]
+            .filter((key) => key.indexOf(this.ODATA_ANNOTATION_PREFIX) > 0)
+            .forEach((key) => {
+            let name = key.substring(0, key.indexOf(this.ODATA_ANNOTATION_PREFIX));
+            let prop = props.has(name) ? props.get(name) : new Map();
+            prop.set(key.substring(key.indexOf(this.ODATA_ANNOTATION_PREFIX)), annots.get(key));
+            props.set(name, prop);
+        });
+        return props;
     },
-    id(value, id) {
-        if (id !== undefined)
-            value[this.ODATA_ID] = id;
-        return this.ODATA_ID in value
-            ? value[this.ODATA_ID]
-            : undefined;
+    id(annots) {
+        return annots instanceof Map
+            ? annots.get(this.ODATA_ID)
+            : annots[this.ODATA_ID];
     },
-    etag(value, etag) {
-        if (etag !== undefined)
-            value[this.ODATA_ETAG] = etag;
-        return this.ODATA_ETAG in value
-            ? value[this.ODATA_ETAG]
-            : undefined;
+    etag(annots) {
+        return annots instanceof Map
+            ? annots.get(this.ODATA_ETAG)
+            : annots[this.ODATA_ETAG];
     },
-    type(value, type) {
-        if (type !== undefined)
-            value[this.ODATA_TYPE] = `#${type}`;
-        if (!(this.ODATA_TYPE in value))
+    type(annots) {
+        let type = annots instanceof Map
+            ? annots.get(this.ODATA_TYPE)
+            : annots[this.ODATA_TYPE];
+        if (!type)
             return undefined;
-        const t = value[this.ODATA_TYPE].substr(1);
-        const matches = COLLECTION.exec(t);
+        type = type.substring(1);
+        const matches = COLLECTION.exec(type);
         if (matches)
             return matches[1].indexOf('.') === -1 ? `Edm.${matches[1]}` : matches[1];
-        return t;
+        return type;
     },
-    mediaEtag(value) {
-        return this.ODATA_MEDIA_ETAG in value
-            ? decodeURIComponent(value[this.ODATA_MEDIA_ETAG])
+    mediaEtag(annots) {
+        return annots.has(this.ODATA_MEDIA_ETAG)
+            ? decodeURIComponent(annots.get(this.ODATA_MEDIA_ETAG))
             : undefined;
     },
-    metadataEtag(value) {
-        return this.ODATA_METADATA_ETAG in value
-            ? decodeURIComponent(value[this.ODATA_METADATA_ETAG])
+    metadataEtag(annots) {
+        return annots.has(this.ODATA_METADATA_ETAG)
+            ? decodeURIComponent(annots.get(this.ODATA_METADATA_ETAG))
             : undefined;
     },
-    count(value) {
-        return this.ODATA_COUNT in value
-            ? Number(value[this.ODATA_COUNT])
+    count(annots) {
+        return annots.has(this.ODATA_COUNT)
+            ? Number(annots.get(this.ODATA_COUNT))
             : undefined;
     },
     annotations(value) {
-        return Object.keys(value)
-            .filter((key) => key.indexOf(this.ODATA_ANNOTATION_PREFIX) !== -1 ||
+        const annots = new Map();
+        Object.entries(value)
+            .filter(([key]) => key.indexOf(this.ODATA_ANNOTATION_PREFIX) !== -1 ||
             key.startsWith(this.ODATA_FUNCTION_PREFIX))
-            .reduce((acc, key) => Object.assign(acc, { [key]: value[key] }), {});
+            .forEach(([key, value]) => annots.set(key, value));
+        return annots;
     },
     attributes(value, metadata) {
         return Object.entries(value)
@@ -3218,39 +3362,39 @@ const ODataVersionBaseHelper = {
                 !k.startsWith(this.ODATA_FUNCTION_PREFIX)))
             .reduce((acc, e) => ({ ...acc, [e[0]]: e[1] }), {});
     },
-    nextLink(value) {
-        return this.ODATA_NEXTLINK in value
-            ? decodeURIComponent(value[this.ODATA_NEXTLINK])
+    nextLink(annots) {
+        return annots.has(this.ODATA_NEXTLINK)
+            ? decodeURIComponent(annots.get(this.ODATA_NEXTLINK))
             : undefined;
     },
-    readLink(value) {
-        return this.ODATA_READLINK in value
-            ? decodeURIComponent(value[this.ODATA_READLINK])
+    readLink(annots) {
+        return annots.has(this.ODATA_READLINK)
+            ? decodeURIComponent(annots.get(this.ODATA_READLINK))
             : undefined;
     },
-    mediaReadLink(value) {
-        return this.ODATA_MEDIA_READLINK in value
-            ? decodeURIComponent(value[this.ODATA_MEDIA_READLINK])
+    mediaReadLink(annots) {
+        return annots.has(this.ODATA_MEDIA_READLINK)
+            ? decodeURIComponent(annots.get(this.ODATA_MEDIA_READLINK))
             : undefined;
     },
-    editLink(value) {
-        return this.ODATA_EDITLINK in value
-            ? decodeURIComponent(value[this.ODATA_EDITLINK])
+    editLink(annots) {
+        return annots.has(this.ODATA_EDITLINK)
+            ? decodeURIComponent(annots.get(this.ODATA_EDITLINK))
             : undefined;
     },
-    mediaEditLink(value) {
-        return this.ODATA_MEDIA_EDITLINK in value
-            ? decodeURIComponent(value[this.ODATA_MEDIA_EDITLINK])
+    mediaEditLink(annots) {
+        return annots.has(this.ODATA_MEDIA_EDITLINK)
+            ? decodeURIComponent(annots.get(this.ODATA_MEDIA_EDITLINK))
             : undefined;
     },
-    deltaLink(value) {
-        return this.ODATA_DELTALINK in value
-            ? decodeURIComponent(value[this.ODATA_DELTALINK])
+    deltaLink(annots) {
+        return annots.has(this.ODATA_DELTALINK)
+            ? decodeURIComponent(annots.get(this.ODATA_DELTALINK))
             : undefined;
     },
-    mediaContentType(value) {
-        return this.ODATA_MEDIA_CONTENTTYPE in value
-            ? decodeURIComponent(value[this.ODATA_MEDIA_CONTENTTYPE])
+    mediaContentType(annots) {
+        return annots.has(this.ODATA_MEDIA_CONTENTTYPE)
+            ? decodeURIComponent(annots.get(this.ODATA_MEDIA_CONTENTTYPE))
             : undefined;
     },
 };
@@ -3269,7 +3413,7 @@ const ODataHelper = {
         //odata.etag: the ETag of the entity
         ODATA_ETAG: '@odata.etag',
         ODATA_METADATA_ETAG: '@odata.metadataEtag',
-        //odata.type: the type of the containing {[name: string]: any} or targeted property if the type of the {[name: string]: any} or targeted property cannot be heuristically determined
+        //odata.type: the type of the containing {[key: string]: any} or targeted property if the type of the {[key: string]: any} or targeted property cannot be heuristically determined
         ODATA_TYPE: '@odata.type',
         //odata.nextLink: the next link of a collection with partial results
         ODATA_NEXTLINK: '@odata.nextLink',
@@ -3300,15 +3444,17 @@ const ODataHelper = {
         //http://nb-mdp-dev01:57970/$metadata#categorias(children(children(children(children(children(children(children(children(children(children()))))))))))/$entity
         //http://nb-mdp-dev01:57970/$metadata#recursos/SIU.Documentos.Documento/$entity
         //http://nb-mdp-dev01:57970/$metadata#SIU.Api.Infrastructure.Storage.Backend.SiuUrls
-        context(value) {
+        context(annots) {
             let ctx = {};
-            if (this.ODATA_CONTEXT in value) {
-                const str = value[this.ODATA_CONTEXT];
+            const str = annots instanceof Map
+                ? annots.get(this.ODATA_CONTEXT)
+                : annots[this.ODATA_CONTEXT];
+            if (typeof str === 'string') {
                 let index = str.indexOf('$metadata');
-                ctx.serviceRootUrl = str.substr(0, index);
+                ctx.serviceRootUrl = str.substring(0, index);
                 index = str.indexOf('#');
-                ctx.metadataUrl = str.substr(0, index);
-                const parts = str.substr(index + 1).split('/');
+                ctx.metadataUrl = str.substring(0, index);
+                const parts = str.substring(index + 1).split('/');
                 const col = COLLECTION.exec(parts[0]);
                 if (col) {
                     ctx.type = col[1];
@@ -3352,15 +3498,17 @@ const ODataHelper = {
         ODATA_TYPE: 'odata.type',
         ODATA_COUNT: 'odata.count',
         VALUE: 'value',
-        context(value) {
+        context(annots) {
             let ctx = {};
-            if (this.ODATA_CONTEXT in value) {
-                const str = value[this.ODATA_CONTEXT];
+            const str = annots instanceof Map
+                ? annots.get(this.ODATA_CONTEXT)
+                : annots[this.ODATA_CONTEXT];
+            if (typeof str === 'string') {
                 let index = str.indexOf('$metadata');
-                ctx.serviceRootUrl = str.substr(0, index);
+                ctx.serviceRootUrl = str.substring(0, index);
                 index = str.indexOf('#');
-                ctx.metadataUrl = str.substr(0, index);
-                const parts = str.substr(index + 1).split('/');
+                ctx.metadataUrl = str.substring(0, index);
+                const parts = str.substring(index + 1).split('/');
                 ctx.entitySet = parts[0];
             }
             return ctx;
@@ -3381,9 +3529,11 @@ const ODataHelper = {
         ODATA_TYPE: 'type',
         VALUE: 'results',
         annotations(value) {
-            if (this.ODATA_ANNOTATION in value)
-                return value[this.ODATA_ANNOTATION];
-            return value;
+            const annots = new Map();
+            if (this.ODATA_ANNOTATION in value) {
+                Object.entries(value[this.ODATA_ANNOTATION]).forEach(([key, value]) => annots.set(key, value));
+            }
+            return annots;
         },
         attributes(value, metadata) {
             return value;
@@ -3399,7 +3549,7 @@ class ODataApiOptions {
     constructor(config) {
         this.etag = { ifMatch: true, ifNoneMatch: false };
         this.version = config.version || DEFAULT_VERSION;
-        this.stringAsEnum = config.stringAsEnum;
+        this.stringAsEnum = config.stringAsEnum || false;
         this.params = config.params || {};
         this.headers = config.headers || {};
         this.withCredentials = config.withCredentials;
@@ -3410,6 +3560,8 @@ class ODataApiOptions {
         Object.assign(this.etag, config.etag || {});
         this.prefer = config.prefer;
         this.deleteRefBy = config.deleteRefBy || 'path';
+        this.nonParenthesisForEmptyParameterFunction =
+            config.nonParenthesisForEmptyParameterFunction || false;
     }
     get helper() {
         return ODataHelper[this.version];
@@ -3418,7 +3570,6 @@ class ODataApiOptions {
 class ODataParserOptions {
     constructor(config) {
         this.version = config.version || DEFAULT_VERSION;
-        this.stringAsEnum = config.stringAsEnum;
     }
     get helper() {
         return ODataHelper[this.version];
@@ -3454,7 +3605,8 @@ class ODataEnumTypeParser extends ODataAnnotatable {
     ttitelize(term) {
         return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
     }
-    configure({ options }) {
+    configure({ stringAsEnum, options }) {
+        this.stringAsEnum = stringAsEnum;
         this.optionsHelper = options;
     }
     isTypeOf(type) {
@@ -3485,13 +3637,13 @@ class ODataEnumTypeParser extends ODataAnnotatable {
             : this.optionsHelper;
         if (this.flags) {
             const names = Enums.toNames(this.members, value);
-            return !parserOptions?.stringAsEnum
+            return !this.stringAsEnum
                 ? `${this.namespace}.${this.name}'${names.join(', ')}'`
                 : names.join(', ');
         }
         else {
             const name = Enums.toName(this.members, value);
-            return !parserOptions?.stringAsEnum
+            return !this.stringAsEnum
                 ? `${this.namespace}.${this.name}'${name}'`
                 : name;
         }
@@ -3502,7 +3654,7 @@ class ODataEnumTypeParser extends ODataAnnotatable {
             ? new ODataParserOptions(options)
             : this.optionsHelper;
         const serialized = this.serialize(value, parserOptions);
-        return parserOptions?.stringAsEnum
+        return this.stringAsEnum
             ? raw(`'${serialized}'`)
             : raw(serialized);
     }
@@ -3593,8 +3745,8 @@ class ODataStructuredTypeFieldParser extends ODataAnnotatable {
     }
     //#region Deserialize
     parse(parser, value, options) {
-        const type = Types.isPlainObject(value)
-            ? options?.helper.type(value)
+        const type = options !== undefined && Types.isPlainObject(value)
+            ? options.helper.type(value)
             : undefined;
         if (type !== undefined) {
             return parser
@@ -3621,8 +3773,8 @@ class ODataStructuredTypeFieldParser extends ODataAnnotatable {
     //#endregion
     //#region Serialize
     toJson(parser, value, options) {
-        const type = Types.isPlainObject(value)
-            ? options?.helper.type(value)
+        const type = options !== undefined && Types.isPlainObject(value)
+            ? options.helper.type(value)
             : undefined;
         if (type !== undefined) {
             return parser
@@ -4030,7 +4182,8 @@ class ODataCallableParser {
             [p.name]: p.encode(params[p.name], parserOptions),
         }), {});
     }
-    configure({ parserForType, options, }) {
+    configure({ nonParenthesisForEmptyParameterFunction, parserForType, options, }) {
+        this.nonParenthesisForEmptyParameterFunction = nonParenthesisForEmptyParameterFunction;
         this.optionsHelper = options;
         if (this.return)
             this.parser = parserForType(this.return.type) || NONE_PARSER;
@@ -4063,7 +4216,11 @@ class ODataCallable extends ODataSchemaElement {
         return path;
     }
     configure({ parserForType, }) {
-        this.parser.configure({ options: this.api.options, parserForType });
+        this.parser.configure({
+            nonParenthesisForEmptyParameterFunction: this.api.options.nonParenthesisForEmptyParameterFunction,
+            options: this.api.options,
+            parserForType
+        });
     }
     /**
      * Deseialize the given value from the callable.
@@ -4123,7 +4280,7 @@ class ODataEnumType extends ODataSchemaElement {
         this.parser = new ODataEnumTypeParser(config, schema.namespace, schema.alias);
     }
     configure() {
-        this.parser.configure({ options: this.api.options });
+        this.parser.configure({ stringAsEnum: this.api.options.stringAsEnum, options: this.api.options });
     }
     /**
      * Returns the fields of the enum type.
@@ -4148,6 +4305,14 @@ class ODataEnumType extends ODataSchemaElement {
     findFieldByValue(value) {
         return this.fields().find((f) => f.value === value);
     }
+    /**
+     * Find a fields by flag.
+     * @param value The value of the field
+     * @returns The fields with the given flag
+     */
+    findFieldsByValue(value) {
+        return this.fields().filter((f) => Boolean(f.value & value));
+    }
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value
@@ -4320,14 +4485,9 @@ class ODataStructuredType extends ODataSchemaElement {
      */
     pick(attrs, { include_parents = true, include_navigation = false, include_etag = true, } = {}) {
         const names = this.fields({ include_parents, include_navigation }).map((f) => f.name);
-        let values = Object.keys(attrs)
-            .filter((k) => names.indexOf(k) !== -1)
-            .reduce((acc, k) => Object.assign(acc, { [k]: attrs[k] }), {});
-        if (include_etag) {
-            const etag = this.api.options.helper.etag(attrs);
-            this.api.options.helper.etag(attrs, etag);
-        }
-        return values;
+        return Object.keys(attrs)
+            .filter((key) => names.indexOf(key) !== -1 || (key == this.api.options.helper.ODATA_ETAG && include_etag))
+            .reduce((acc, key) => Object.assign(acc, { [key]: attrs[key] }), {});
     }
     /**
      * Deseialize the given value from the structured type.
@@ -4555,29 +4715,28 @@ class ODataResource {
             query: this.cloneQuery(),
         });
     }
+    __parser(value, options, type) {
+        const dataType = options !== undefined && Types.isPlainObject(value)
+            ? options.helper.type(value)
+            : undefined;
+        if (dataType !== undefined) {
+            // Parser from data type
+            return this.api.parserForType(dataType);
+        }
+        else if (this.schema !== undefined && 'parser' in this.schema) {
+            // Parser from resource schema
+            return this.schema.parser;
+        }
+        else if (type !== undefined) {
+            // Parser from resource type
+            return this.api.parserForType(type);
+        }
+        return undefined;
+    }
     deserialize(value, options) {
         const resourceType = this.returnType();
-        const resourceSchema = this.schema;
-        const _p = (value, options) => {
-            const dataType = Types.isPlainObject(value)
-                ? options.helper.type(value)
-                : undefined;
-            if (dataType !== undefined) {
-                // Parser from data type
-                return this.api.parserForType(dataType);
-            }
-            else if (resourceSchema !== undefined && 'parser' in resourceSchema) {
-                // Parser from resource schema
-                return resourceSchema.parser;
-            }
-            else if (resourceType !== undefined) {
-                // Parser from resource type
-                return this.api.parserForType(resourceType);
-            }
-            return undefined;
-        };
         const _d = (value, options) => {
-            const parser = _p(value, options);
+            const parser = this.__parser(value, options, resourceType);
             return parser !== undefined && 'deserialize' in parser
                 ? parser.deserialize(value, options)
                 : value;
@@ -4588,27 +4747,8 @@ class ODataResource {
     }
     serialize(value, options) {
         const resourceType = this.type();
-        const resourceSchema = this.schema;
-        const _p = (value, options) => {
-            const dataType = Types.isPlainObject(value)
-                ? options.helper.type(value)
-                : undefined;
-            if (dataType !== undefined) {
-                // Parser from data type
-                return this.api.parserForType(dataType);
-            }
-            else if (resourceSchema !== undefined && 'parser' in resourceSchema) {
-                // Parser from resource schema
-                return resourceSchema.parser;
-            }
-            else if (resourceType !== undefined) {
-                // Parser from resource type
-                return this.api.parserForType(resourceType);
-            }
-            return undefined;
-        };
         const _s = (value, options) => {
-            const parser = _p(value, options);
+            const parser = this.__parser(value, options, resourceType);
             return parser !== undefined && 'serialize' in parser
                 ? parser.serialize(value, options)
                 : value;
@@ -4619,27 +4759,8 @@ class ODataResource {
     }
     encode(value, options) {
         const resourceType = this.type();
-        const resourceSchema = this.schema;
-        const _p = (value, options) => {
-            const dataType = Types.isPlainObject(value)
-                ? options.helper.type(value)
-                : undefined;
-            if (dataType !== undefined) {
-                // Parser from data type
-                return this.api.parserForType(dataType);
-            }
-            else if (resourceSchema !== undefined && 'parser' in resourceSchema) {
-                // Parser from resource schema
-                return resourceSchema.parser;
-            }
-            else if (resourceType !== undefined) {
-                // Parser from resource type
-                return this.api.parserForType(resourceType);
-            }
-            return undefined;
-        };
         const _e = (value, options) => {
-            const parser = _p(value, options);
+            const parser = this.__parser(value, options, resourceType);
             return parser !== undefined && 'encode' in parser
                 ? parser.encode(value, options)
                 : value;
@@ -4856,7 +4977,7 @@ class ODataActionResource extends ODataResource {
 }
 
 class ODataAnnotations {
-    constructor(helper, annotations = {}, context) {
+    constructor(helper, annotations = new Map(), context) {
         this.helper = helper;
         this.annotations = annotations;
         this.context = context;
@@ -4873,7 +4994,7 @@ class ODataAnnotations {
 }
 class ODataPropertyAnnotations extends ODataAnnotations {
     clone() {
-        return new ODataPropertyAnnotations(this.helper, { ...this.annotations }, this.context);
+        return new ODataPropertyAnnotations(this.helper, new Map(this.annotations), this.context);
     }
     data(data) {
         return this.helper.property(data);
@@ -4881,7 +5002,7 @@ class ODataPropertyAnnotations extends ODataAnnotations {
 }
 class ODataEntityAnnotations extends ODataAnnotations {
     clone() {
-        return new ODataEntityAnnotations(this.helper, { ...this.annotations }, this.context);
+        return new ODataEntityAnnotations(this.helper, new Map(this.annotations), this.context);
     }
     data(data) {
         return this.helper.entity(data);
@@ -4920,7 +5041,7 @@ class ODataEntityAnnotations extends ODataAnnotations {
         return this._properties;
     }
     property(name) {
-        return this.properties[name];
+        return this.properties.get(name);
     }
     get functions() {
         if (this._functions === undefined) {
@@ -4934,7 +5055,7 @@ class ODataEntityAnnotations extends ODataAnnotations {
 }
 class ODataEntitiesAnnotations extends ODataAnnotations {
     clone() {
-        return new ODataEntitiesAnnotations(this.helper, { ...this.annotations }, this.context);
+        return new ODataEntitiesAnnotations(this.helper, new Map(this.annotations), this.context);
     }
     data(data) {
         return this.helper.entities(data);
@@ -4977,7 +5098,6 @@ class ODataEntitiesAnnotations extends ODataAnnotations {
 class ODataResponseOptions {
     constructor(config) {
         this.version = config.version || DEFAULT_VERSION;
-        this.stringAsEnum = config.stringAsEnum;
     }
     get helper() {
         return ODataHelper[this.version];
@@ -5116,13 +5236,13 @@ class ODataResponse extends HttpResponse {
             if (key) {
                 const etag = this.headers.get(key);
                 if (etag)
-                    options.helper.etag(this._annotations, etag);
+                    this._annotations.set(options.helper.ODATA_ETAG, etag);
             }
             key = Http.resolveHeaderKey(this.headers, ODATA_ENTITYID_HEADERS);
             if (key) {
                 const entityId = this.headers.get(key);
                 if (entityId)
-                    options.helper.id(this._annotations, entityId);
+                    this._annotations.set(options.helper.ODATA_ID, entityId);
             }
         }
         return this._annotations;
@@ -6360,6 +6480,14 @@ class ODataFunctionResource extends ODataResource {
             ? this.schema.parser.return?.type
             : undefined;
     }
+    pathAndParams(escape = false) {
+        let [path, params] = super.pathAndParams(escape);
+        if (path.endsWith('()') &&
+            this.api.options.nonParenthesisForEmptyParameterFunction) {
+            path = path.substring(0, path.length - 2);
+        }
+        return [path, params];
+    }
     parameters(params, { alias } = {}) {
         let parameters = params !== null ? this.encode(params) : null;
         if (alias && parameters !== null) {
@@ -7065,7 +7193,7 @@ class ODataEntityResource extends ODataResource {
         if (castSchema !== undefined &&
             baseSchema !== undefined &&
             !castSchema.isSubtypeOf(baseSchema))
-            throw new Error(`Cannot cast to ${type}`);
+            throw new Error(`cast: Cannot cast to ${type}`);
         const segments = this.cloneSegments();
         segments.add(PathSegmentNames.type, type).type(type);
         return new ODataEntityResource(this.api, {
@@ -7106,7 +7234,7 @@ class ODataEntityResource extends ODataResource {
     }
     fetch(options) {
         if (!this.hasKey())
-            return throwError('Entity resource without key');
+            return throwError(() => new Error('fetch: Entity resource without key'));
         return this.get(options);
     }
     fetchEntity(options) {
@@ -7424,6 +7552,18 @@ class ODataModelEvent {
                 : '')
             .join('');
     }
+    //Identifies the current model for the event
+    get currentModel() {
+        const link = this.chain.find((c) => ODataModelOptions.isModel(c[0]));
+        return link !== undefined ? link[0] : undefined;
+    }
+    //Identifies the current collection for the event
+    get currentCollection() {
+        const link = this.chain.find((c) => ODataModelOptions.isCollection(c[0]));
+        return link !== undefined
+            ? link[0]
+            : undefined;
+    }
 }
 const BUBBLING = [
     'change',
@@ -7621,8 +7761,8 @@ class ODataModelField {
     }
     annotationsFactory(base) {
         return this.parser.collection
-            ? new ODataEntitiesAnnotations(base.helper, base.property(this.parser.name) || {})
-            : new ODataEntityAnnotations(base.helper, base.property(this.parser.name) || {});
+            ? new ODataEntitiesAnnotations(base.helper, base.property(this.parser.name))
+            : new ODataEntityAnnotations(base.helper, base.property(this.parser.name));
     }
     schemaFactory(base) {
         return this.api.findStructuredTypeForType(this.parser.type);
@@ -7752,30 +7892,35 @@ class ODataModelOptions {
         return chain;
     }
     static resource(child) {
-        let resource = undefined;
+        let resource = null;
+        let prevField = null;
         for (let [model, field] of ODataModelOptions.chain(child)) {
             resource = resource || model._resource;
-            if (resource === undefined)
+            if (resource === null)
                 break;
-            if (ODataModelOptions.isModel(model)) {
-                let key = model.key({
+            if (ODataModelOptions.isModel(model) &&
+                (prevField === null || prevField.collection)) {
+                // Resolve key
+                let modelKey = model.key({
                     field_mapping: true,
                 });
-                if (key !== undefined)
+                if (modelKey !== undefined)
                     resource =
                         resource instanceof ODataEntitySetResource
-                            ? resource.entity(key)
-                            : resource.key(key);
+                            ? resource.entity(modelKey)
+                            : resource.key(modelKey);
             }
+            prevField = field;
             if (field === null) {
+                // Apply the query from model to new resource
                 const query = model._resource?.cloneQuery().toQueryArguments();
-                if (query !== undefined && resource !== undefined)
+                if (query !== undefined)
                     resource.query((q) => q.apply(query));
                 continue;
             }
             resource = field.resourceFactory(resource);
         }
-        if (resource === undefined)
+        if (resource === null)
             throw new Error(`resource: Can't build resource for ${child}`);
         return resource;
     }
@@ -7926,8 +8071,8 @@ class ODataModelOptions {
         return !Types.isEmpty(defs) ? defs : undefined;
     }
     hasChanged(self, { include_navigation = false } = {}) {
-        return (!Types.isEmpty(self._changes) ||
-            Object.values(self._relations)
+        return (self._changes.size != 0 ||
+            [...self._relations.values()]
                 .filter(({ field }) => !field.navigation || include_navigation)
                 .some(({ field, state, model }) => (!include_navigation || field.navigation) &&
                 (state === ODataModelState.Changed ||
@@ -7968,7 +8113,7 @@ class ODataModelOptions {
             include_computed,
             include_non_field,
         });
-        let relations = Object.entries(self._relations)
+        let relations = [...self._relations.entries()]
             .filter(
         // Chain
         ([, { model }]) => chain.every((c) => c !== model))
@@ -8045,19 +8190,19 @@ class ODataModelOptions {
                 (ODataModelOptions.isCollection(self._parent[0]) &&
                     self._parent[0]._model
                         .meta !== self._meta))) {
-            this.api.options.helper.type(entity, this.schema.type());
+            entity[this.api.options.helper.ODATA_TYPE] = `#${this.schema.type()}`;
         }
         return entity;
     }
     attributes(self, { changes_only = false, include_concurrency = false, include_computed = false, include_non_field = false, field_mapping = false, } = {}) {
         // Attributes by fields (attributes for the model type)
         const fieldAttrs = this.fields().reduce((acc, f) => {
-            const isChanged = f.name in self._changes;
+            const isChanged = self._changes.has(f.name);
             const name = field_mapping ? f.field : f.name;
             const computed = f.annotatedValue(COMPUTED);
             const value = isChanged
-                ? self._changes[f.name]
-                : self._attributes[f.name];
+                ? self._changes.get(f.name)
+                : self._attributes.get(f.name);
             if (f.concurrency && include_concurrency) {
                 return Object.assign(acc, { [name]: value });
             }
@@ -8084,10 +8229,10 @@ class ODataModelOptions {
         return { ...fieldAttrs, ...nonFieldAttrs };
     }
     reset(self, { name, silent = false } = {}) {
-        if (!Types.isEmpty(name) && name in self._changes) {
-            const value = self._attributes[name];
-            const previous = self._changes[name];
-            delete self._changes[name];
+        if (!Types.isEmpty(name) && self._changes.has(name)) {
+            const value = self._attributes.get(name);
+            const previous = self._changes.get(name);
+            self._changes.delete(name);
             if (!silent) {
                 self.events$.emit(new ODataModelEvent('change', {
                     model: self,
@@ -8098,14 +8243,14 @@ class ODataModelOptions {
             }
         }
         else if (Types.isEmpty(name)) {
-            const entries = Object.entries(self._changes);
-            self._changes = {};
+            const entries = [...self._changes.entries()];
+            self._changes.clear();
             if (!silent) {
                 entries.forEach((entry) => {
                     self.events$.emit(new ODataModelEvent('change', {
                         track: entry[0],
                         model: self,
-                        value: self._attributes[entry[0]],
+                        value: self._attributes.get(entry[0]),
                         previous: entry[1],
                     }));
                 });
@@ -8176,7 +8321,7 @@ class ODataModelOptions {
     }
     _get(self, field) {
         if (field.isStructuredType()) {
-            return self._relations[field.name]?.model;
+            return self._relations.get(field.name)?.model;
         }
         else {
             return this.attributes(self, {
@@ -8188,13 +8333,13 @@ class ODataModelOptions {
     _setStructured(self, field, value) {
         let changed = false;
         // Ensures that the relation exists
-        if (!(field.name in self._relations)) {
-            self._relations[field.name] = {
+        if (!self._relations.has(field.name)) {
+            self._relations.set(field.name, {
                 state: ODataModelState.Unchanged,
                 field: field,
-            };
+            });
         }
-        const relation = self._relations[field.name];
+        const relation = self._relations.get(field.name);
         const currentModel = relation.model;
         if (value === null) {
             relation.model = value;
@@ -8277,14 +8422,14 @@ class ODataModelOptions {
         const currentValue = attrs[field];
         changed = !Types.isEqual(currentValue, value);
         if (self._reset) {
-            delete self._changes[field];
-            self._attributes[field] = value;
+            self._changes.delete(field);
+            self._attributes.set(field, value);
         }
-        else if (Types.isEqual(value, self._attributes[field])) {
-            delete self._changes[field];
+        else if (Types.isEqual(value, self._attributes.get(field))) {
+            self._changes.delete(field);
         }
         else if (changed) {
-            self._changes[field] = value;
+            self._changes.set(field, value);
         }
         if (!self._silent && changed) {
             self.events$.emit(new ODataModelEvent('change', {
@@ -8348,7 +8493,7 @@ class ODataCollection {
         if (model === undefined && Klass.model !== null)
             model = Klass.model;
         if (model === undefined)
-            throw new Error('Collection need model');
+            throw new Error('Collection: Collection need model');
         this._model = model;
         // Parent
         if (parent !== undefined) {
@@ -8386,7 +8531,7 @@ class ODataCollection {
         if (this._resource !== null &&
             this._resource.type() !== resource.type() &&
             !this._resource.isSubtypeOf(resource))
-            throw new Error(`Can't reattach ${this._resource.type()} to ${resource.type()}`);
+            throw new Error(`attach: Can't reattach ${this._resource.type()} to ${resource.type()}`);
         this._entries.forEach(({ model }) => {
             const mr = this._model.meta.modelResourceFactory(resource.cloneQuery());
             model.attach(mr);
@@ -8406,7 +8551,7 @@ class ODataCollection {
         const query = this.resource().cloneQuery();
         let resource = this._model.meta.collectionResourceFactory(query);
         if (resource === undefined)
-            throw new Error('Collection does not have associated EntitySet endpoint');
+            throw new Error('asEntitySet: Collection does not have associated EntitySet endpoint');
         // Store parent and resource
         const store = { parent: this._parent, resource: this._resource };
         // Replace parent and resource
@@ -8434,7 +8579,7 @@ class ODataCollection {
     modelFactory(data, { reset = false } = {}) {
         let Model = this._model;
         const helper = this._annotations.helper;
-        const annots = new ODataEntityAnnotations(helper, helper.annotations(data) || {});
+        const annots = new ODataEntityAnnotations(helper, helper.annotations(data));
         if (annots?.type !== undefined && Model.meta !== null) {
             let schema = Model.meta.findChildOptions((o) => o.isTypeOf(annots.type))?.schema;
             if (schema !== undefined && schema.model !== undefined)
@@ -8481,26 +8626,13 @@ class ODataCollection {
     }
     fetch({ withCount, ...options } = {}) {
         const resource = this.resource();
-        if (resource === undefined)
-            return throwError('fetch: Resource is undefined');
-        let obs$;
-        if (resource instanceof ODataEntitySetResource) {
-            obs$ = resource.fetch({ withCount, ...options });
-        }
-        else if (resource instanceof ODataNavigationPropertyResource) {
-            obs$ = resource.fetch({
+        const obs$ = resource instanceof ODataEntitySetResource
+            ? resource.fetch({ withCount, ...options })
+            : resource.fetch({
                 responseType: 'entities',
                 withCount,
                 ...options,
             });
-        }
-        else {
-            obs$ = resource.fetch({
-                responseType: 'entities',
-                withCount,
-                ...options,
-            });
-        }
         this.events$.emit(new ODataModelEvent('request', { collection: this, value: obs$ }));
         return obs$.pipe(map(({ entities, annots }) => {
             this._annotations = annots;
@@ -8511,10 +8643,8 @@ class ODataCollection {
     }
     fetchAll(options) {
         const resource = this.resource();
-        if (resource === undefined)
-            return throwError('fetchAll: Resource is undefined');
         if (resource instanceof ODataPropertyResource)
-            return throwError('fetchAll: Resource is ODataPropertyResource');
+            return throwError(() => new Error('fetchAll: Resource is ODataPropertyResource'));
         const obs$ = resource.fetchAll(options);
         this.events$.emit(new ODataModelEvent('request', {
             collection: this,
@@ -8538,10 +8668,8 @@ class ODataCollection {
      */
     save({ relModel = false, method, ...options } = {}) {
         const resource = this.resource();
-        if (resource === undefined)
-            return throwError('saveAll: Resource is undefined');
         if (resource instanceof ODataPropertyResource)
-            return throwError('fetchAll: Resource is ODataPropertyResource');
+            return throwError(() => new Error('save: Resource is ODataPropertyResource'));
         let toDestroyEntity = [];
         let toRemoveReference = [];
         let toDestroyContained = [];
@@ -8831,7 +8959,7 @@ class ODataCollection {
                     }
                     else {
                         const helper = this._annotations.helper;
-                        const annots = new ODataEntityAnnotations(helper, helper.annotations(obj) || {});
+                        const annots = new ODataEntityAnnotations(helper, helper.annotations(obj));
                         const entity = annots.attributes(obj, 'full');
                         model._annotations = annots;
                         model.assign(entity, { reset, silent });
@@ -8911,25 +9039,25 @@ class ODataCollection {
                     return func.call(params, { responseType, ...options });
             }
         }
-        return throwError(`Can't function without ODataEntitySetResource`);
+        return throwError(() => new Error(`callFunction: Can't function without ODataEntitySetResource`));
     }
     callAction(name, params, responseType, { ...options } = {}) {
         const resource = this.resource();
-        if (resource instanceof ODataEntitySetResource) {
-            const action = resource.action(name);
-            action.query((q) => q.apply(options));
-            switch (responseType) {
-                case 'property':
-                    return action.callProperty(params, options);
-                case 'model':
-                    return action.callModel(params, options);
-                case 'collection':
-                    return action.callCollection(params, options);
-                default:
-                    return action.call(params, { responseType, ...options });
-            }
+        if (!(resource instanceof ODataEntitySetResource)) {
+            return throwError(() => new Error(`callAction: Can't action without ODataEntitySetResource`));
+        }
+        const action = resource.action(name);
+        action.query((q) => q.apply(options));
+        switch (responseType) {
+            case 'property':
+                return action.callProperty(params, options);
+            case 'model':
+                return action.callModel(params, options);
+            case 'collection':
+                return action.callCollection(params, options);
+            default:
+                return action.call(params, { responseType, ...options });
         }
-        return throwError(`Can't action without ODataEntitySetResource`);
     }
     _unsubscribe(entry) {
         if (entry.subscription) {
@@ -8939,7 +9067,7 @@ class ODataCollection {
     }
     _subscribe(entry) {
         if (entry.subscription) {
-            throw new Error('Subscription already exists');
+            throw new Error('Collection: Subscription already exists');
         }
         entry.subscription = entry.model.events$.subscribe((event) => {
             if (BUBBLING.indexOf(event.name) !== -1 &&
@@ -8988,12 +9116,18 @@ class ODataCollection {
             },
         };
     }
-    filter(predicate) {
+    filter(predicate, thisArg) {
         return this.models().filter(predicate);
     }
-    find(predicate) {
+    map(callbackfn, thisArg) {
+        return this.models().map(callbackfn, thisArg);
+    }
+    find(predicate, thisArg) {
         return this.models().find(predicate);
     }
+    reduce(callbackfn, initialValue) {
+        return this.models().reduce(callbackfn, initialValue);
+    }
     first() {
         return this.models()[0];
     }
@@ -9090,9 +9224,9 @@ class ODataModel {
     constructor(data = {}, { parent, resource, annots, reset = false, } = {}) {
         // Parent
         this._parent = null;
-        this._attributes = {};
-        this._changes = {};
-        this._relations = {};
+        this._attributes = new Map();
+        this._changes = new Map();
+        this._relations = new Map();
         this._resource = null;
         this._reset = false;
         this._reparent = false;
@@ -9101,7 +9235,7 @@ class ODataModel {
         this.events$ = new EventEmitter();
         const Klass = this.constructor;
         if (Klass.meta === undefined)
-            throw new Error(`Can't create model without metadata`);
+            throw new Error(`ODataModel: Can't create model without metadata`);
         this._meta = Klass.meta;
         this._meta.bind(this, { parent, resource, annots });
         // Client Id
@@ -9141,19 +9275,19 @@ class ODataModel {
     navigationProperty(name) {
         const field = this._meta.field(name);
         if (field === undefined || !field.navigation)
-            throw Error(`Can't find navigation property ${name}`);
+            throw Error(`navigationProperty: Can't find navigation property ${name}`);
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            throw Error("Can't get navigation without ODataEntityResource with key");
+            throw Error("navigationProperty: Can't get navigation without ODataEntityResource with key");
         return field.resourceFactory(resource);
     }
     property(name) {
         const field = this._meta.field(name);
         if (field === undefined || field.navigation)
-            throw Error(`Can't find property ${name}`);
+            throw Error(`property: Can't find property ${name}`);
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            throw Error("Can't get property without ODataEntityResource with key");
+            throw Error("property: Can't get property without ODataEntityResource with key");
         return field.resourceFactory(resource);
     }
     attach(resource) {
@@ -9298,11 +9432,11 @@ class ODataModel {
     fetch({ ...options } = {}) {
         let resource = this.resource();
         if (resource === undefined)
-            return throwError('fetch: Resource is undefined');
+            return throwError(() => new Error('fetch: Resource is undefined'));
         let obs$;
         if (resource instanceof ODataEntityResource) {
             if (!resource.hasKey())
-                return throwError("fetch: Can't fetch model without key");
+                return throwError(() => new Error("fetch: Can't fetch model without key"));
             obs$ = resource.fetch(options);
         }
         else if (resource instanceof ODataNavigationPropertyResource) {
@@ -9319,49 +9453,45 @@ class ODataModel {
     save({ method, navigation = false, validate = true, ...options } = {}) {
         let resource = this.resource();
         if (resource === undefined)
-            return throwError('save: Resource is undefined');
+            return throwError(() => new Error('save: Resource is undefined'));
         if (!(resource instanceof ODataEntityResource ||
             resource instanceof ODataNavigationPropertyResource))
-            return throwError('save: Resource type ODataEntityResource/ODataNavigationPropertyResource needed');
+            return throwError(() => new Error('save: Resource type ODataEntityResource/ODataNavigationPropertyResource needed'));
         // Resolve method and resource key
         if (method === undefined && this.schema().isCompoundKey())
-            return throwError('save: Composite key require a specific method, use create/update/modify');
+            return throwError(() => new Error('save: Composite key require a specific method, use create/update/modify'));
         method = method || (!resource.hasKey() ? 'create' : 'update');
         if (resource instanceof ODataEntityResource &&
             (method === 'update' || method === 'modify') &&
             !resource.hasKey())
-            return throwError('save: Update/Patch require entity key');
+            return throwError(() => new Error('save: Update/Patch require entity key'));
         if (resource instanceof ODataNavigationPropertyResource ||
             method === 'create')
             resource.clearKey();
-        let obs$;
-        if (!validate || this.isValid({ method, navigation })) {
-            const _entity = this.toEntity({
-                changes_only: method === 'modify',
-                field_mapping: true,
-                include_concurrency: true,
-                include_navigation: navigation,
-            });
-            obs$ = (method === 'create'
-                ? resource.create(_entity, options)
-                : method === 'modify'
-                    ? resource.modify(_entity, { etag: this.annots().etag, ...options })
-                    : resource.update(_entity, { etag: this.annots().etag, ...options })).pipe(map(({ entity, annots }) => ({ entity: entity || _entity, annots })));
-        }
-        else {
-            obs$ = throwError(this._errors);
+        if (validate && !this.isValid({ method, navigation })) {
+            return throwError(() => new Error('save: Validation errors'));
         }
-        return this._request(obs$);
+        const _entity = this.toEntity({
+            changes_only: method === 'modify',
+            field_mapping: true,
+            include_concurrency: true,
+            include_navigation: navigation,
+        });
+        return this._request((method === 'create'
+            ? resource.create(_entity, options)
+            : method === 'modify'
+                ? resource.modify(_entity, { etag: this.annots().etag, ...options })
+                : resource.update(_entity, { etag: this.annots().etag, ...options })).pipe(map(({ entity, annots }) => ({ entity: entity || _entity, annots }))));
     }
     destroy({ ...options } = {}) {
         let resource = this.resource();
         if (resource === undefined)
-            return throwError('destroy: Resource is undefined');
+            return throwError(() => new Error('destroy: Resource is undefined'));
         if (!(resource instanceof ODataEntityResource ||
             resource instanceof ODataNavigationPropertyResource))
-            return throwError('destroy: Resource type ODataEntityResource/ODataNavigationPropertyResource needed');
+            return throwError(() => new Error('destroy: Resource type ODataEntityResource/ODataNavigationPropertyResource needed'));
         if (!resource.hasKey())
-            return throwError("destroy: Can't destroy model without key");
+            return throwError(() => new Error("destroy: Can't destroy model without key"));
         const _entity = this.toEntity({ field_mapping: true });
         const obs$ = resource
             .destroy({ etag: this.annots().etag, ...options })
@@ -9394,7 +9524,7 @@ class ODataModel {
     callFunction(name, params, responseType, { ...options } = {}) {
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            return throwError("Can't call function without ODataEntityResource with key");
+            return throwError(() => new Error("callFunction: Can't call function without ODataEntityResource with key"));
         const func = resource.function(name).query((q) => q.apply(options));
         switch (responseType) {
             case 'property':
@@ -9410,7 +9540,7 @@ class ODataModel {
     callAction(name, params, responseType, { ...options } = {}) {
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
-            return throwError("Can't call action without ODataEntityResource with key");
+            return throwError(() => new Error("callAction: Can't call action without ODataEntityResource with key"));
         const action = resource.action(name).query((q) => q.apply(options));
         switch (responseType) {
             case 'property':
@@ -9427,7 +9557,7 @@ class ODataModel {
     cast(type) {
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource))
-            throw new Error(`Can't cast to derived model without ODataEntityResource`);
+            throw new Error(`cast: Can't cast to derived model without ODataEntityResource`);
         return resource
             .cast(type)
             .asModel(this.toEntity(INCLUDE_DEEP), { annots: this.annots() });
@@ -9446,7 +9576,7 @@ class ODataModel {
     getValue(name, options) {
         const field = this._meta.field(name);
         if (field === undefined || field.navigation)
-            throw Error(`Can't find property ${name}`);
+            throw Error(`getValue: Can't find property ${name}`);
         let value = this[name];
         if (value === undefined) {
             const prop = field.resourceFactory(this.resource());
@@ -9493,7 +9623,7 @@ class ODataModel {
     getReference(name) {
         const field = this._meta.field(name);
         if (field === undefined || !field.navigation)
-            throw Error(`Can't find navigation property ${name}`);
+            throw Error(`getReference: Can't find navigation property ${name}`);
         let model = this[name];
         if (model === undefined) {
             const value = field.collection ? [] : this.referenced(field);
@@ -9540,14 +9670,19 @@ class ODataApi {
         // Memoize
         this.memo = {
             forType: {
-                enum: {},
-                structured: {},
-                callable: {},
-                entitySet: {},
-                parser: {},
-                options: {},
+                enum: new Map(),
+                structured: new Map(),
+                callable: new Map(),
+                entitySet: new Map(),
+                parser: new Map(),
+                options: new Map(),
+            },
+            byName: {
+                enum: new Map(),
+                structured: new Map(),
+                callable: new Map(),
+                entitySet: new Map(),
             },
-            byName: { enum: {}, structured: {}, callable: {}, entitySet: {} },
         };
         this.serviceRootUrl = config.serviceRootUrl;
         if (this.serviceRootUrl.indexOf('?') != -1)
@@ -9674,28 +9809,29 @@ class ODataApi {
             .pop();
     }
     findEnumTypeForType(type) {
-        if (!(type in this.memo.forType.enum))
-            this.memo.forType.enum[type] =
-                this.findSchemaForType(type)?.findEnumTypeForType(type);
-        return this.memo.forType.enum[type];
+        if (!this.memo.forType.enum.has(type)) {
+            this.memo.forType.enum.set(type, this.findSchemaForType(type)?.findEnumTypeForType(type));
+        }
+        return this.memo.forType.enum.get(type);
     }
     findStructuredTypeForType(type) {
-        if (!(type in this.memo.forType.structured))
-            this.memo.forType.structured[type] =
-                this.findSchemaForType(type)?.findStructuredTypeForType(type);
-        return this.memo.forType.structured[type];
+        if (!this.memo.forType.structured.has(type)) {
+            this.memo.forType.structured.set(type, this.findSchemaForType(type)?.findStructuredTypeForType(type));
+        }
+        return this.memo.forType.structured.get(type);
     }
     findCallableForType(type, bindingType) {
         const key = bindingType !== undefined ? `${bindingType}/${type}` : type;
-        if (!(key in this.memo.forType.callable))
-            this.memo.forType.callable[key] = this.findSchemaForType(type)?.findCallableForType(type, bindingType);
-        return this.memo.forType.callable[key];
+        if (!this.memo.forType.callable.has(key)) {
+            this.memo.forType.callable.set(key, this.findSchemaForType(type)?.findCallableForType(type, bindingType));
+        }
+        return this.memo.forType.callable.get(key);
     }
     findEntitySetForType(type) {
-        if (!(type in this.memo.forType.entitySet))
-            this.memo.forType.entitySet[type] =
-                this.findSchemaForType(type)?.findEntitySetForType(type);
-        return this.memo.forType.entitySet[type];
+        if (!this.memo.forType.entitySet.has(type)) {
+            this.memo.forType.entitySet.set(type, this.findSchemaForType(type)?.findEntitySetForType(type));
+        }
+        return this.memo.forType.entitySet.get(type);
     }
     findModelForType(type) {
         return this.findStructuredTypeForType(type)?.model;
@@ -9742,44 +9878,49 @@ class ODataApi {
         return this.findEntitySetForType(type)?.service;
     }
     findEntitySetForEntityType(entityType) {
-        if (!(entityType in this.memo.forType.entitySet))
-            this.memo.forType.entitySet[entityType] = this.schemas
+        if (!this.memo.forType.entitySet.has(entityType)) {
+            this.memo.forType.entitySet.set(entityType, this.schemas
                 .reduce((acc, schema) => [...acc, ...schema.entitySets], [])
-                .find((e) => e.entityType === entityType);
-        return this.memo.forType.entitySet[entityType];
+                .find((e) => e.entityType === entityType));
+        }
+        return this.memo.forType.entitySet.get(entityType);
     }
     findServiceForEntityType(entityType) {
         return this.findEntitySetForEntityType(entityType)?.service;
     }
     findEnumTypeByName(name) {
-        if (!(name in this.memo.byName.enum))
-            this.memo.byName.enum[name] = this.schemas
+        if (!this.memo.byName.enum.has(name)) {
+            this.memo.byName.enum.set(name, this.schemas
                 .reduce((acc, schema) => [...acc, ...schema.enums], [])
-                .find((e) => e.name === name);
-        return this.memo.byName.enum[name];
+                .find((e) => e.name === name));
+        }
+        return this.memo.byName.enum.get(name);
     }
     findStructuredTypeByName(name) {
-        if (!(name in this.memo.byName.structured))
-            this.memo.byName.structured[name] = this.schemas
+        if (!this.memo.byName.structured.has(name)) {
+            this.memo.byName.structured.set(name, this.schemas
                 .reduce((acc, schema) => [...acc, ...schema.entities], [])
-                .find((e) => e.name === name);
-        return this.memo.byName.structured[name];
+                .find((e) => e.name === name));
+        }
+        return this.memo.byName.structured.get(name);
     }
     findCallableByName(name, bindingType) {
         const key = bindingType !== undefined ? `${bindingType}/${name}` : name;
-        if (!(key in this.memo.byName.callable))
-            this.memo.byName.callable[key] = this.schemas
+        if (!this.memo.byName.callable.has(key)) {
+            this.memo.byName.callable.set(key, this.schemas
                 .reduce((acc, schema) => [...acc, ...schema.callables], [])
                 .find((c) => c.name === name &&
-                (bindingType === undefined || c.binding()?.type === bindingType));
-        return this.memo.byName.callable[key];
+                (bindingType === undefined || c.binding()?.type === bindingType)));
+        }
+        return this.memo.byName.callable.get(key);
     }
     findEntitySetByName(name) {
-        if (!(name in this.memo.byName.entitySet))
-            this.memo.byName.entitySet[name] = this.schemas
+        if (!this.memo.byName.entitySet.has(name)) {
+            this.memo.byName.entitySet.set(name, this.schemas
                 .reduce((acc, schema) => [...acc, ...schema.entitySets], [])
-                .find((e) => e.name === name);
-        return this.memo.byName.entitySet[name];
+                .find((e) => e.name === name));
+        }
+        return this.memo.byName.entitySet.get(name);
     }
     findModelByName(name) {
         return this.findStructuredTypeByName(name)?.model;
@@ -9792,35 +9933,34 @@ class ODataApi {
     }
     parserForType(type, bindingType) {
         const key = bindingType !== undefined ? `${bindingType}/${type}` : type;
-        if (!(key in this.memo.forType.parser)) {
+        if (!this.memo.forType.parser.has(key)) {
             if (type in this.parsers) {
                 // Edm, Base Parsers
-                this.memo.forType.parser[key] = this.parsers[type];
+                this.memo.forType.parser.set(key, this.parsers[type]);
             }
             else if (!type.startsWith('Edm.')) {
                 // EnumType, ComplexType and EntityType Parsers
                 let value = this.findCallableForType(type, bindingType) ||
                     this.findEnumTypeForType(type) ||
                     this.findStructuredTypeForType(type);
-                this.memo.forType.parser[key] = value?.parser;
+                this.memo.forType.parser.set(key, value?.parser);
             }
             else {
                 // None Parser
-                this.memo.forType.parser[key] = NONE_PARSER;
+                this.memo.forType.parser.set(key, NONE_PARSER);
             }
         }
-        return this.memo.forType.parser[key];
+        return this.memo.forType.parser.get(key);
     }
     findOptionsForType(type) {
         // Strucutred Options
-        if (!(type in this.memo.forType.options)) {
+        if (!this.memo.forType.options.has(type)) {
             let st = this.findStructuredTypeForType(type);
-            this.memo.forType.options[type] =
-                st !== undefined && st.model !== undefined && st.model?.meta !== null
-                    ? st.model.meta
-                    : undefined;
+            this.memo.forType.options.set(type, st !== undefined && st.model !== undefined && st.model?.meta !== null
+                ? st.model.meta
+                : undefined);
         }
-        return this.memo.forType.options[type];
+        return this.memo.forType.options.get(type);
     }
 }
 
@@ -10282,9 +10422,9 @@ class ODataClient {
         return this.request('PUT', resource, addBody(options, body));
     }
 }
-ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: ODataSettings }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataClient, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataClient, decorators: [{
+ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: ODataSettings }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ODataClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataClient, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -10403,7 +10543,7 @@ class ODataEntitySetService extends ODataEntityService {
     update(key, attrs, options) {
         const res = this.entity(key);
         if (!res.hasKey())
-            return throwError('Resource without key');
+            return throwError(() => new Error('update: Resource without key'));
         return res.update(attrs, options);
     }
     /**
@@ -10416,7 +10556,7 @@ class ODataEntitySetService extends ODataEntityService {
     modify(key, attrs, options) {
         const res = this.entity(key);
         if (!res.hasKey())
-            return throwError('Resource without key');
+            return throwError(() => new Error('modify: Resource without key'));
         return res.modify(attrs, options);
     }
     /**
@@ -10428,7 +10568,7 @@ class ODataEntitySetService extends ODataEntityService {
     destroy(key, options) {
         const res = this.entity(key);
         if (!res.hasKey())
-            return throwError('Resource without key');
+            return throwError(() => new Error('destroy: Resource without key'));
         return res.destroy(options);
     }
     //#region Shortcuts
@@ -10457,12 +10597,12 @@ class ODataEntitySetService extends ODataEntityService {
     save(attrs, { etag, method, ...options } = {}) {
         let schema = this.structuredTypeSchema;
         if (method === undefined && schema !== undefined && schema.isCompoundKey())
-            return throwError('Composite key require a specific method, use create/update/patch');
+            return throwError(() => new Error('save: Composite key require a specific method, use create/update/patch'));
         let key = schema && schema.resolveKey(attrs);
         if (method === undefined)
             method = key !== undefined ? 'update' : 'create';
         if ((method === 'update' || method === 'modify') && key === undefined)
-            return throwError("Can't update/patch entity without key");
+            return throwError(() => new Error("save: Can't update/patch entity without key"));
         return method === 'create'
             ? this.create(attrs, options)
             : method === 'modify'
@@ -10540,9 +10680,9 @@ class ODataServiceFactory {
         })(this.client, singletonName, apiNameOrEntityType);
     }
 }
-ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataServiceFactory });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataServiceFactory, decorators: [{
+ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
+ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataServiceFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataServiceFactory, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: ODataClient }]; } });
 
@@ -10566,10 +10706,10 @@ class ODataModule {
         };
     }
 }
-ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataModule, imports: [HttpClientModule] });
-ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [[HttpClientModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: ODataModule, decorators: [{
+ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataModule, imports: [HttpClientModule] });
+ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [[HttpClientModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ODataModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [HttpClientModule],