angular-odata 0.122.0 → 0.124.0

package/{fesm2020 → fesm2022}/angular-odata.mjs

@@ -231,7 +231,9 @@ class ODataCache {
         const tags = [];
         const context = res.context;
         if (context.entitySet) {
-            tags.push(context.key ? `${context.entitySet}(${context.key})` : context.entitySet);
+            tags.push(context.key
+                ? `${context.entitySet}(${context.key})`
+                : context.entitySet);
         }
         if (context.type)
             tags.push(context.type);
@@ -453,6 +455,8 @@ const binary = (value) => ({
 const isQueryCustomType = (value) => typeof value === 'object' &&
     'type' in value &&
     value.type in QueryCustomTypes;
+const isRawType = (value) => isQueryCustomType(value) &&
+    value.type === QueryCustomTypes.Raw;
 const ITEM_ROOT = '';
 function builder ({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, } = {}) {
     const [path, params] = buildPathAndQuery({
@@ -483,45 +487,67 @@ function buildPathAndQuery({ select, search, skiptoken, format, top, skip, filte
     if (key != undefined) {
         path += `(${normalizeValue(key, { aliases, escape })})`;
     }
+    // Select
     if (select) {
-        query.$select = Array.isArray(select) ? select.join(',') : select;
+        query.$select = isRawType(select)
+            ? select.value
+            : Array.isArray(select)
+                ? select.join(',')
+                : select;
     }
+    // Search
     if (search) {
         query.$search = search;
     }
+    // Skiptoken
     if (skiptoken) {
         query.$skiptoken = skiptoken;
     }
+    // Format
     if (format) {
         query.$format = format;
     }
+    // Filter
     if (filter || typeof count === 'object') {
         query.$filter = buildFilter(typeof count === 'object' ? count : filter, {
             aliases,
             escape,
         });
     }
+    // Transform
     if (transform) {
         query.$apply = buildTransforms(transform, { aliases, escape });
     }
+    // Expand
     if (expand) {
         query.$expand = buildExpand(expand, { aliases, escape });
     }
+    // OrderBy
     if (orderBy) {
         query.$orderby = buildOrderBy(orderBy);
     }
-    if (count) {
-        if (typeof count === 'boolean') {
-            query.$count = true;
-        }
-        else {
-            path += '/$count';
-        }
+    // Count
+    if (isRawType(count)) {
+        query.$count = count.value;
+    }
+    else if (typeof count === 'boolean') {
+        query.$count = true;
+    }
+    else if (count) {
+        path += '/$count';
+    }
+    // Top
+    if (isRawType(top)) {
+        query.$top = top.value;
     }
-    if (typeof top === 'number') {
+    else if (typeof top === 'number') {
         query.$top = top;
     }
-    if (typeof skip === 'number') {
+    // Skip
+    if (isRawType(skip)) {
+        query.$top = skip.value;
+    }
+    else if (typeof skip === 'number') {
         query.$skip = skip;
     }
     if (action) {
@@ -572,7 +598,11 @@ function buildFilter(filters = {}, { aliases, propPrefix, escape, }) {
     }, []).join(' and ');
     function buildFilterCore(filter = {}, { aliases, propPrefix, escape, }) {
         let filterExpr = '';
-        if (typeof filter === 'string') {
+        if (isRawType(filter)) {
+            // Use raw query custom filter string
+            filterExpr = filter.value;
+        }
+        else if (typeof filter === 'string') {
             // Use raw filter string
             filterExpr = filter;
         }
@@ -830,8 +860,11 @@ function normalizeValue(value, { aliases, escape = false, } = {}) {
     }
     return value;
 }
-function buildExpand(expands, { aliases, escape = false }) {
-    if (typeof expands === 'number') {
+function buildExpand(expands, { aliases, escape = false, }) {
+    if (isRawType(expands)) {
+        return expands.value;
+    }
+    else if (typeof expands === 'number') {
         return expands;
     }
     else if (typeof expands === 'string') {
@@ -883,6 +916,8 @@ function buildExpand(expands, { aliases, escape = false }) {
                     case 'top':
                     case 'skip':
                         value = `${expands[key]}`;
+                        if (isRawType(value))
+                            value = value.value;
                         break;
                     default:
                         value = buildExpand(expands[key], { aliases, escape });
@@ -902,7 +937,7 @@ function buildExpand(expands, { aliases, escape = false }) {
     }
     return '';
 }
-function buildTransforms(transforms, { aliases, escape = false }) {
+function buildTransforms(transforms, { aliases, escape = false, }) {
     // Wrap single object an array for simplified processing
     const transformsArray = Array.isArray(transforms) ? transforms : [transforms];
     const transformsResult = transformsArray.reduce((result, transform) => {
@@ -952,7 +987,7 @@ function buildAggregate(aggregate) {
     })
         .join(',');
 }
-function buildGroupBy(groupBy, { aliases, escape = false }) {
+function buildGroupBy(groupBy, { aliases, escape = false, }) {
     if (!groupBy.properties) {
         throw new Error(`'properties' property required for groupBy`);
     }
@@ -963,7 +998,10 @@ function buildGroupBy(groupBy, { aliases, escape = false }) {
     return result;
 }
 function buildOrderBy(orderBy, prefix = '') {
-    if (Array.isArray(orderBy)) {
+    if (isRawType(orderBy)) {
+        return orderBy.value;
+    }
+    else if (Array.isArray(orderBy)) {
         return orderBy
             .map((value) => Array.isArray(value) &&
             value.length === 2 &&
@@ -1091,6 +1129,22 @@ const Enums = {
         }
         return [];
     },
+    toFlags(enums, value) {
+        if (typeof value === 'number') {
+            return this.values(enums)
+                .filter((v) => v !== 0 && (value & v) === v)
+                .map((v) => this.toName(enums, v));
+        }
+        if (typeof value === 'string') {
+            value = value.split(',').map((o) => o.trim());
+        }
+        if (Array.isArray(value) && value.every((v) => v in enums)) {
+            return value
+                .filter((v) => enums[v])
+                .map((v) => this.toName(enums, v));
+        }
+        return [];
+    },
 };
 
 function cloneSymbol(targe) {
@@ -1106,6 +1160,9 @@ const Types = {
     rawType(value) {
         return Object.prototype.toString.call(value).slice(8, -1);
     },
+    isObject(value) {
+        return typeof value === 'object' && value !== null;
+    },
     isPlainObject(value) {
         if (this.rawType(value) !== 'Object') {
             return false;
@@ -1602,39 +1659,36 @@ class Expression {
     }
 }
 
-let Field$1 = class Field {
-    constructor(name = '') {
-        this.name = name;
-    }
-    static factory(name = '') {
-        return new Proxy({ _name: name }, new Field$1());
-    }
+const FieldFactory = (names = []) => new Proxy({ _names: names }, {
     get(target, key) {
-        let name = target['_name'];
+        let names = target['_names'];
         if (key === 'render') {
-            return ({ prefix }) => prefix ? `${prefix}/${name}` : name;
+            return ({ prefix }) => prefix ? `${prefix}/${names.join('/')}` : names.join('/');
         }
         else if (key === 'clone') {
-            return () => Field$1.factory(name);
+            return () => FieldFactory([...names]);
         }
-        else if (key === Symbol.toStringTag) {
-            return () => 'Field';
+        else if (key === 'isField') {
+            return () => true;
         }
         else if (key === 'toJSON') {
             return () => ({
-                $type: Types.rawType(this),
-                name: name,
+                $type: 'Field',
+                names: names,
             });
         }
+        else if (key === 'resolve') {
+            return (parser) => names.reduce((acc, name) => acc.field(name), parser);
+        }
         else {
-            name = name ? `${name}/${key}` : key;
-            return new Proxy({ _name: name }, this);
+            return FieldFactory([...names, key]);
         }
-    }
+    },
     has(target, key) {
-        return ['toJSON', 'clone', 'render'].includes(key) || key in target;
-    }
-};
+        return (['toJSON', 'isField', 'clone', 'render', 'resolve'].includes(key) ||
+            key in target);
+    },
+});
 function applyMixins(derivedCtor, constructors) {
     constructors.forEach((baseCtor) => {
         Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
@@ -1643,24 +1697,38 @@ function applyMixins(derivedCtor, constructors) {
         });
     });
 }
-function render(value, { aliases, normalize, escape, prefix, } = {}) {
-    if (typeof value === 'function') {
-        return render(value(syntax), { aliases, normalize, prefix });
+function render(value, { aliases, normalize, escape, prefix, parser, } = {}) {
+    if (Types.isFunction(value)) {
+        return render(value(syntax), { aliases, normalize, prefix, parser });
     }
-    if (typeof value === 'object' &&
-        value !== null &&
-        value.render !== undefined) {
-        return render(value.render({ aliases, escape, prefix }), {
+    if (Types.isObject(value) && 'render' in value) {
+        return render(value.render({ aliases, escape, prefix, parser }), {
             aliases,
             normalize,
             escape,
             prefix,
+            parser,
         });
     }
     return normalize ? normalizeValue(value, { aliases, escape }) : value;
 }
+function resolve(values, parser) {
+    if (parser !== undefined) {
+        let fields = values.filter((v) => Types.isObject(v) && 'isField' in v && v.isField());
+        if (fields.length === 1 && Types.isObject(parser) && 'field' in parser) {
+            return fields[0].resolve(parser);
+        }
+    }
+    return parser;
+}
+function encode(values, parser) {
+    if (parser !== undefined) {
+        return values.map((v) => Types.isObject(v) || v === null ? v : parser?.encode(v));
+    }
+    return values;
+}
 class Function {
-    constructor(name, values, normalize = true, escape = false) {
+    constructor(name, values, normalize, escape = false) {
         this.name = name;
         this.values = values;
         this.normalize = normalize;
@@ -1673,16 +1741,29 @@ class Function {
         return {
             $type: Types.rawType(this),
             name: this.name,
-            values: this.values,
+            values: this.values.map((v) => Types.isObject(v) && 'toJSON' in v ? v.toJSON() : v),
             normalize: this.normalize,
         };
     }
-    render({ aliases, escape, prefix, }) {
-        let [field, ...values] = this.values;
-        field = render(field, { aliases, escape, prefix });
+    render({ aliases, escape, prefix, parser, }) {
+        parser = resolve(this.values, parser);
+        let [left, ...values] = encode(this.values, parser);
+        left = render(left, {
+            aliases,
+            escape,
+            prefix,
+            parser,
+            normalize: this.normalize === 'all' || this.normalize === 'left',
+        });
         const params = [
-            field,
-            ...values.map((v) => render(v, { aliases, escape, prefix, normalize: this.normalize })),
+            left,
+            ...values.map((v) => render(v, {
+                aliases,
+                escape,
+                prefix,
+                parser,
+                normalize: this.normalize === 'all' || this.normalize === 'right',
+            })),
         ];
         return `${this.name}(${params.join(', ')})`;
     }
@@ -1691,135 +1772,135 @@ class Function {
     }
 }
 class StringAndCollectionFunctions {
-    concat(field, value, normalize) {
-        return new Function('concat', [field, value], normalize);
+    concat(left, right, normalize = 'right') {
+        return new Function('concat', [left, right], normalize);
     }
-    contains(field, value, normalize) {
-        return new Function('contains', [field, value], normalize);
+    contains(left, right, normalize = 'right') {
+        return new Function('contains', [left, right], normalize);
     }
-    endsWith(field, value, normalize) {
-        return new Function('endswith', [field, value], normalize);
+    endsWith(left, right, normalize = 'right') {
+        return new Function('endswith', [left, right], normalize);
     }
-    indexOf(field, value, normalize) {
-        return new Function('indexof', [field, value], normalize);
+    indexOf(left, right, normalize = 'right') {
+        return new Function('indexof', [left, right], normalize);
     }
-    length(value, normalize) {
-        return new Function('length', [value], normalize);
+    length(left, normalize = 'right') {
+        return new Function('length', [left], normalize);
     }
-    startsWith(field, value, normalize) {
-        return new Function('startswith', [field, value], normalize);
+    startsWith(left, right, normalize = 'right') {
+        return new Function('startswith', [left, right], normalize);
     }
-    subString(field, start, length) {
-        let values = [field, start];
+    subString(left, right, length, normalize = 'none') {
+        let values = [left, right];
         if (length !== undefined) {
             values.push(length);
         }
-        return new Function('substring', values);
+        return new Function('substring', values, normalize);
     }
 }
 class CollectionFunctions {
-    hasSubset(s1, s2) {
-        return new Function('hassubset', [s1, s2]);
+    hasSubset(left, right, normalize = 'none') {
+        return new Function('hassubset', [left, right], normalize);
     }
-    hasSubsequence(s1, s2) {
-        return new Function('hassubsequence', [s1, s2]);
+    hasSubsequence(left, right, normalize = 'none') {
+        return new Function('hassubsequence', [left, right], normalize);
     }
 }
 class StringFunctions {
-    matchesPattern(value, pattern) {
-        return new Function('matchesPattern', [value, pattern]);
+    matchesPattern(left, pattern, normalize = 'none') {
+        return new Function('matchesPattern', [left, pattern], normalize);
     }
-    toLower(value) {
-        return new Function('tolower', [value]);
+    toLower(left, normalize = 'none') {
+        return new Function('tolower', [left], normalize);
     }
-    toUpper(value) {
-        return new Function('toupper', [value]);
+    toUpper(left, normalize = 'none') {
+        return new Function('toupper', [left], normalize);
     }
-    trim(value) {
-        return new Function('trim', [value]);
+    trim(left, normalize = 'none') {
+        return new Function('trim', [left], normalize);
     }
 }
 class DateAndTimeFunctions {
-    date(value) {
-        return new Function('date', [value]);
+    date(left, normalize = 'none') {
+        return new Function('date', [left], normalize);
     }
-    day(value) {
-        return new Function('day', [value]);
+    day(left, normalize = 'none') {
+        return new Function('day', [left], normalize);
     }
-    fractionalseconds(value) {
-        return new Function('fractionalseconds', [value]);
+    fractionalseconds(left, normalize = 'none') {
+        return new Function('fractionalseconds', [left], normalize);
     }
-    hour(value) {
-        return new Function('hour', [value]);
+    hour(left, normalize = 'none') {
+        return new Function('hour', [left], normalize);
     }
-    maxdatetime(value) {
-        return new Function('maxdatetime', [value]);
+    maxdatetime(left, normalize = 'none') {
+        return new Function('maxdatetime', [left], normalize);
     }
-    mindatetime(value) {
-        return new Function('mindatetime', [value]);
+    mindatetime(left, normalize = 'none') {
+        return new Function('mindatetime', [left], normalize);
     }
-    minute(value) {
-        return new Function('minute', [value]);
+    minute(left, normalize = 'none') {
+        return new Function('minute', [left], normalize);
     }
-    month(value) {
-        return new Function('month', [value]);
+    month(left, normalize = 'none') {
+        return new Function('month', [left], normalize);
     }
     now() {
-        return new Function('now', []);
+        return new Function('now', [], 'none');
     }
-    second(value) {
-        return new Function('second', [value]);
+    second(left, normalize = 'none') {
+        return new Function('second', [left], normalize);
     }
-    time(value) {
-        return new Function('time', [value]);
+    time(left, normalize = 'none') {
+        return new Function('time', [left], normalize);
     }
-    totaloffsetminutes(value) {
-        return new Function('totaloffsetminutes', [value]);
+    totaloffsetminutes(left, normalize = 'none') {
+        return new Function('totaloffsetminutes', [left], normalize);
     }
-    totalseconds(value) {
-        return new Function('totalseconds', [value]);
+    totalseconds(left, normalize = 'none') {
+        return new Function('totalseconds', [left], normalize);
     }
-    year(value) {
-        return new Function('year', [value]);
+    year(left, normalize = 'none') {
+        return new Function('year', [left], normalize);
     }
 }
 class ArithmeticFunctions {
-    ceiling(value) {
-        return new Function('ceiling', [value]);
+    ceiling(left, normalize = 'none') {
+        return new Function('ceiling', [left], normalize);
     }
-    floor(value) {
-        return new Function('floor', [value]);
+    floor(left, normalize = 'none') {
+        return new Function('floor', [left], normalize);
     }
-    round(value) {
-        return new Function('round', [value]);
+    round(left, normalize = 'none') {
+        return new Function('round', [left], normalize);
     }
 }
 class TypeFunctions {
-    cast(value, type) {
-        return new Function('cast', [value, type]);
+    cast(left, right, normalize = 'right') {
+        return new Function('cast', [left, right], normalize);
     }
-    isof(value, type) {
-        return new Function('isof', [value, type]);
+    isof(left, right, normalize = 'right') {
+        return new Function('isof', [left, right], normalize);
     }
 }
 class GeoFunctions {
-    geoDistance(value, point, normalize) {
-        return new Function('geo.distance', [value, point], normalize);
+    geoDistance(left, right, normalize = 'right') {
+        return new Function('geo.distance', [left, right], normalize);
     }
-    geoIntersects(value, polygon, normalize) {
-        return new Function('geo.intersects', [value, polygon], normalize);
+    geoIntersects(left, right, normalize = 'right') {
+        return new Function('geo.intersects', [left, right], normalize);
     }
-    geoLength(line, normalize) {
-        return new Function('geo.length', [line], normalize);
+    geoLength(left, normalize = 'none') {
+        return new Function('geo.length', [left], normalize);
     }
 }
 class ConditionalFunctions {
-    case(condition, value) {
-        return new Function('case', [condition, value]);
+    case(left, right, normalize = 'none') {
+        return new Function('case', [left, right], normalize);
     }
 }
 class Operator {
-    constructor(op, values, normalize = true) {
+    constructor(op, values, normalize) {
         this.op = op;
         this.values = values;
         this.normalize = normalize;
@@ -1831,13 +1912,20 @@ class Operator {
         return {
             $type: Types.rawType(this),
             op: this.op,
-            values: this.values,
+            values: this.values.map((v) => Types.isObject(v) && 'toJSON' in v ? v.toJSON() : v),
             normalize: this.normalize,
         };
     }
-    render({ aliases, escape, prefix, }) {
-        let [left, right] = this.values;
-        left = render(left, { aliases, escape, prefix });
+    render({ aliases, escape, prefix, parser, }) {
+        parser = resolve(this.values, parser);
+        let [left, right] = encode(this.values, parser);
+        left = render(left, {
+            aliases,
+            escape,
+            prefix,
+            parser,
+            normalize: this.normalize === 'all' || this.normalize === 'left',
+        });
         if (right !== undefined) {
             right = Array.isArray(right)
                 ? `(${right
@@ -1845,14 +1933,16 @@ class Operator {
                     aliases,
                     escape,
                     prefix,
-                    normalize: this.normalize,
+                    parser,
+                    normalize: this.normalize === 'all' || this.normalize === 'right',
                 }))
                     .join(',')})`
                 : render(right, {
                     aliases,
                     escape,
                     prefix,
-                    normalize: this.normalize,
+                    parser,
+                    normalize: this.normalize === 'all' || this.normalize === 'right',
                 });
             return `${left} ${this.op} ${right}`;
         }
@@ -1863,59 +1953,59 @@ class Operator {
     }
 }
 class LogicalOperators {
-    eq(left, right, normalize) {
+    eq(left, right, normalize = 'right') {
         return new Operator('eq', [left, right], normalize);
     }
-    ne(left, right, normalize) {
+    ne(left, right, normalize = 'right') {
         return new Operator('ne', [left, right], normalize);
     }
-    gt(left, right, normalize) {
+    gt(left, right, normalize = 'right') {
         return new Operator('gt', [left, right], normalize);
     }
-    ge(left, right, normalize) {
+    ge(left, right, normalize = 'right') {
         return new Operator('ge', [left, right], normalize);
     }
-    lt(left, right, normalize) {
+    lt(left, right, normalize = 'right') {
         return new Operator('lt', [left, right], normalize);
     }
-    le(left, right, normalize) {
+    le(left, right, normalize = 'right') {
         return new Operator('le', [left, right], normalize);
     }
     /*
-    and(left: any, right: any, normalize?: boolean) {
+    and(left: any, right: any, normalize: Normalize = 'right') {
       return new Operator('and', [left, right], normalize);
     }
-    or(left: any, right: any, normalize?: boolean) {
+    or(left: any, right: any, normalize: Normalize = 'right') {
       return new Operator('or', [left, right], normalize);
     }
     */
-    not(value, normalize) {
-        return new Operator('not', [value], normalize);
+    not(left, normalize = 'none') {
+        return new Operator('not', [left], normalize);
     }
-    has(left, right, normalize) {
+    has(left, right, normalize = 'right') {
         return new Operator('has', [left, right], normalize);
     }
-    in(left, right, normalize) {
+    in(left, right, normalize = 'right') {
         return new Operator('in', [left, right], normalize);
     }
 }
 class ArithmeticOperators {
-    add(left, right, normalize) {
+    add(left, right, normalize = 'right') {
         return new Operator('add', [left, right], normalize);
     }
-    sub(left, right, normalize) {
+    sub(left, right, normalize = 'right') {
         return new Operator('sub', [left, right], normalize);
     }
-    mul(left, right, normalize) {
+    mul(left, right, normalize = 'right') {
         return new Operator('mul', [left, right], normalize);
     }
-    div(left, right, normalize) {
+    div(left, right, normalize = 'right') {
         return new Operator('div', [left, right], normalize);
     }
-    mod(left, right, normalize) {
+    mod(left, right, normalize = 'right') {
         return new Operator('mod', [left, right], normalize);
     }
-    neg(value, normalize) {
+    neg(value, normalize = 'right') {
         return new Operator('-', [value], normalize);
     }
 }
@@ -1932,8 +2022,8 @@ class Grouping {
             group: this.group.toJSON(),
         };
     }
-    render({ aliases, escape, prefix, }) {
-        return `(${render(this.group, { aliases, escape, prefix })})`;
+    render({ aliases, escape, prefix, parser, }) {
+        return `(${render(this.group, { aliases, escape, prefix, parser })})`;
     }
     clone() {
         return new Grouping(Objects.clone(this.group));
@@ -1952,19 +2042,21 @@ class Lambda {
         return {
             $type: Types.rawType(this),
             op: this.op,
-            values: this.values,
+            values: this.values.map((v) => Types.isObject(v) && 'toJSON' in v ? v.toJSON() : v),
             alias: this.alias,
         };
     }
-    render({ aliases, escape, prefix, }) {
-        let [left, right] = this.values;
-        left = render(left, { aliases, escape, prefix });
+    render({ aliases, escape, prefix, parser, }) {
+        parser = resolve(this.values, parser);
+        let [left, right] = encode(this.values, parser);
+        left = render(left, { aliases, escape, prefix, parser });
         if (right) {
             let alias = this.alias || left.split('/').pop().toLowerCase()[0];
             return `${left}/${this.op}(${alias}:${render(right, {
                 aliases,
                 escape,
                 prefix: alias,
+                parser,
             })})`;
         }
         else {
@@ -1976,11 +2068,11 @@ class Lambda {
     }
 }
 class LambdaOperators {
-    any(field, value, alias) {
-        return new Lambda('any', [field, value], alias);
+    any(left, right, alias) {
+        return new Lambda('any', [left, right], alias);
     }
-    all(field, value, alias) {
-        return new Lambda('all', [field, value], alias);
+    all(left, right, alias) {
+        return new Lambda('all', [left, right], alias);
     }
 }
 class ODataOperators {
@@ -2016,12 +2108,12 @@ class ComputeExpression extends Expression {
     }
     static compute(opts, current) {
         return opts({
-            t: Field$1.factory(),
+            t: FieldFactory(),
             e: () => new ComputeExpression(),
         }, current);
     }
-    render({ aliases, escape, prefix, } = {}) {
-        let children = this._children.map((n) => n.render({ aliases, escape, prefix }));
+    render({ aliases, escape, prefix, parser, } = {}) {
+        let children = this._children.map((n) => n.render({ aliases, escape, prefix, parser }));
         return this.names
             .map((name, index) => `${children[index]} as ${name}`)
             .join(',');
@@ -2059,7 +2151,7 @@ class CountField {
             field: this.field.toJSON(),
         };
     }
-    render({ aliases, escape, prefix, }) {
+    render({ aliases, escape, prefix, parser, }) {
         const params = [
             QueryOption.filter,
             QueryOption.search,
@@ -2068,11 +2160,21 @@ class CountField {
             .reduce((acc, key) => {
             let value = this.values[key];
             if (Types.rawType(value).endsWith('Expression')) {
-                value = value.render({ aliases, prefix, escape });
+                value = value.render({
+                    aliases,
+                    prefix,
+                    escape,
+                    parser,
+                });
             }
             return Object.assign(acc, { [key]: value });
         }, {});
-        let count = `${render(this.field, { aliases, escape, prefix })}/$count`;
+        let count = `${render(this.field, {
+            aliases,
+            escape,
+            prefix,
+            parser,
+        })}/$count`;
         if (!Types.isEmpty(params)) {
             count = `${count}(${Object.keys(params)
                 .map((key) => `$${key}=${params[key]}`)
@@ -2100,7 +2202,7 @@ class CountExpression extends Expression {
     }
     static count(opts, current) {
         return opts({
-            t: Field$1.factory(),
+            t: FieldFactory(),
             e: () => new CountExpression(),
         }, current);
     }
@@ -2108,9 +2210,9 @@ class CountExpression extends Expression {
         this._children.push(node);
         return this;
     }
-    render({ aliases, escape, prefix, } = {}) {
+    render({ aliases, escape, prefix, parser, } = {}) {
         let content = this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
+            .map((n) => n.render({ aliases, escape, prefix, parser }))
             .join(`,`);
         return content;
     }
@@ -2123,7 +2225,7 @@ class CountExpression extends Expression {
         let countField = new CountField(field);
         if (opts !== undefined)
             opts({
-                t: Field$1.factory(),
+                t: FieldFactory(),
                 f: countField,
             });
         return this._add(countField);
@@ -2138,8 +2240,8 @@ class FilterExpression extends Expression {
     }
     static filter(opts, current) {
         return opts({
-            t: Field$1.factory(),
             e: (connector = 'and') => new FilterExpression({ connector }),
+            t: FieldFactory(),
             o: operators,
             f: functions,
         }, current);
@@ -2157,9 +2259,9 @@ class FilterExpression extends Expression {
     negated() {
         return this._negated;
     }
-    render({ aliases, escape, prefix, } = {}) {
+    render({ aliases, escape, prefix, parser, } = {}) {
         let content = this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
+            .map((n) => n.render({ aliases, escape, prefix, parser }))
             .join(` ${this._connector} `);
         if (this._negated) {
             content = `not (${content})`;
@@ -2230,44 +2332,44 @@ class FilterExpression extends Expression {
         });
         return this._add(notExp, this._connector);
     }
-    eq(left, right, normalize) {
+    eq(left, right, normalize = 'right') {
         return this._add(operators.eq(left, right, normalize));
     }
-    ne(left, right, normalize) {
+    ne(left, right, normalize = 'right') {
         return this._add(operators.ne(left, right, normalize));
     }
-    gt(left, right, normalize) {
+    gt(left, right, normalize = 'right') {
         return this._add(operators.gt(left, right, normalize));
     }
-    ge(left, right, normalize) {
+    ge(left, right, normalize = 'right') {
         return this._add(operators.ge(left, right, normalize));
     }
-    lt(left, right, normalize) {
+    lt(left, right, normalize = 'right') {
         return this._add(operators.lt(left, right, normalize));
     }
-    le(left, right, normalize) {
+    le(left, right, normalize = 'right') {
         return this._add(operators.le(left, right, normalize));
     }
-    has(left, right, normalize) {
+    has(left, right, normalize = 'right') {
         return this._add(operators.has(left, right, normalize));
     }
-    in(left, right, normalize) {
+    in(left, right, normalize = 'right') {
         return this._add(operators.in(left, right, normalize));
     }
-    contains(left, right, normalize) {
+    contains(left, right, normalize = 'right') {
         return this._add(functions.contains(left, right, normalize));
     }
-    startsWith(left, right, normalize) {
+    startsWith(left, right, normalize = 'right') {
         return this._add(functions.startsWith(left, right, normalize));
     }
-    endsWith(left, right, normalize) {
+    endsWith(left, right, normalize = 'right') {
         return this._add(functions.endsWith(left, right, normalize));
     }
     any(left, opts, alias) {
         let exp = undefined;
         if (opts !== undefined) {
             exp = opts({
-                t: Field$1.factory(),
+                t: FieldFactory(),
                 e: (connector = 'and') => new FilterExpression({ connector }),
             });
         }
@@ -2275,7 +2377,7 @@ class FilterExpression extends Expression {
     }
     all(left, opts, alias) {
         const exp = opts({
-            t: Field$1.factory(),
+            t: FieldFactory(),
             e: (connector = 'and') => new FilterExpression({ connector }),
         });
         return this._add(syntax.all(left, exp, alias));
@@ -2302,8 +2404,8 @@ class OrderByField {
             order: this.order,
         };
     }
-    render({ aliases, escape, prefix, }) {
-        return `${render(this.field, { aliases, escape, prefix })} ${this.order}`;
+    render({ aliases, escape, prefix, parser, }) {
+        return `${render(this.field, { aliases, escape, prefix, parser })} ${this.order}`;
     }
     clone() {
         return new OrderByField(this.field.clone(), this.order);
@@ -2315,7 +2417,7 @@ class OrderByExpression extends Expression {
     }
     static orderBy(opts, current) {
         return opts({
-            t: Field$1.factory(),
+            t: FieldFactory(),
             e: () => new OrderByExpression(),
         }, current);
     }
@@ -2323,9 +2425,9 @@ class OrderByExpression extends Expression {
         this._children.push(node);
         return this;
     }
-    render({ aliases, escape, prefix, } = {}) {
+    render({ aliases, escape, prefix, parser, } = {}) {
         let content = this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
+            .map((n) => n.render({ aliases, escape, prefix, parser }))
             .join(`,`);
         return content;
     }
@@ -2355,8 +2457,8 @@ class SearchTerm {
             value: this.value,
         };
     }
-    render({ aliases, escape, prefix, }) {
-        return `${render(this.value, { aliases, escape, prefix })}`;
+    render({ aliases, escape, prefix, parser, }) {
+        return `${render(this.value, { aliases, escape, prefix, parser })}`;
     }
     clone() {
         return new SearchTerm(this.value);
@@ -2416,9 +2518,9 @@ class SearchExpression extends Expression {
         }
         return this;
     }
-    render({ aliases, escape, prefix, } = {}) {
+    render({ aliases, escape, prefix, parser, } = {}) {
         let content = this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
+            .map((n) => n.render({ aliases, escape, prefix, parser }))
             .join(` ${this._connector} `);
         return content;
     }
@@ -2467,13 +2569,13 @@ class SelectExpression extends Expression {
     }
     static select(opts, current) {
         return opts({
-            t: Field$1.factory(),
+            t: FieldFactory(),
             e: () => new SelectExpression(),
         }, current);
     }
-    render({ aliases, escape, prefix, } = {}) {
+    render({ aliases, escape, prefix, parser, } = {}) {
         return this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
+            .map((n) => n.render({ aliases, escape, prefix, parser }))
             .join(',');
     }
     clone() {
@@ -2503,7 +2605,8 @@ class ExpandField {
             field: this.field.toJSON(),
         };
     }
-    render({ aliases, escape, prefix, }) {
+    render({ aliases, escape, prefix, parser, }) {
+        parser = resolve([this.field], parser);
         const params = [
             QueryOption.select,
             QueryOption.expand,
@@ -2512,17 +2615,23 @@ class ExpandField {
             QueryOption.orderBy,
             QueryOption.skip,
             QueryOption.top,
+            QueryOption.count,
             QueryOption.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 });
+                value = value.render({
+                    aliases,
+                    prefix,
+                    escape,
+                    parser,
+                });
             }
             return Object.assign(acc, { [key]: value });
         }, {});
-        let expand = `${render(this.field, { aliases, escape, prefix })}`;
+        let expand = `${render(this.field, { aliases, escape, prefix, parser })}`;
         if (!Types.isEmpty(params)) {
             expand = `${expand}(${Object.keys(params)
                 .map((key) => `$${key}=${params[key]}`)
@@ -2532,7 +2641,7 @@ class ExpandField {
     }
     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);
+        return new ExpandField(typeof this.field === 'string' ? this.field : this.field.clone(), values);
     }
     select(opts) {
         return this.option(QueryOption.select, SelectExpression.select(opts, this.values[QueryOption.select]));
@@ -2558,6 +2667,9 @@ class ExpandField {
     levels(n) {
         return this.option(QueryOption.levels, n);
     }
+    count() {
+        return this.option(QueryOption.count, true);
+    }
     // Option Handler
     option(name, opts) {
         if (opts !== undefined)
@@ -2571,13 +2683,13 @@ class ExpandExpression extends Expression {
     }
     static expand(opts, current) {
         return opts({
-            t: Field$1.factory(),
+            t: FieldFactory(),
             e: () => new ExpandExpression(),
         }, current);
     }
-    render({ aliases, escape, prefix, } = {}) {
+    render({ aliases, escape, prefix, parser, } = {}) {
         return this._children
-            .map((n) => n.render({ aliases, escape, prefix }))
+            .map((n) => n.render({ aliases, escape, prefix, parser }))
             .join(',');
     }
     clone() {
@@ -2986,7 +3098,7 @@ class ODataQueryOptions {
                 : new Map(Object.entries(values || {}));
     }
     // Params
-    pathAndParams(escape = false) {
+    pathAndParams({ escape, parser, } = {}) {
         let aliases = [];
         let options = [
             QueryOption.select,
@@ -3011,16 +3123,16 @@ class ODataQueryOptions {
                     value.some((v) => Types.rawType(v).endsWith('Expression')))) {
                 value = Types.isArray(value)
                     ? value.map((v) => Types.rawType(v).endsWith('Expression')
-                        ? v.render({ aliases })
+                        ? raw(v.render({ aliases, escape, parser }))
                         : v)
-                    : value.render({ aliases });
+                    : raw(value.render({ aliases, escape, parser }));
             }
             return Object.assign(acc, { [key]: value });
         }, {});
         return buildPathAndQuery({ ...options, aliases, escape });
     }
-    toString() {
-        const [path, params] = this.pathAndParams();
+    toString({ escape, parser, } = {}) {
+        const [path, params] = this.pathAndParams({ escape, parser });
         return (path +
             Object.entries(params)
                 .filter(([, value]) => !Types.isEmpty(value))
@@ -3156,7 +3268,7 @@ class ODataPathSegmentsHandler {
     }
 }
 
-function pathSegmentsBuilder(segment, escape = false) {
+function pathSegmentsBuilder(segment, escape = false, parser) {
     if (segment.name === PathSegment.function) {
         let [path, params] = segment.parameters
             ? buildPathAndQuery({
@@ -3184,9 +3296,9 @@ class ODataPathSegments {
     constructor(segments) {
         this._segments = segments || [];
     }
-    pathAndParams(escape = false) {
+    pathAndParams({ escape, parser, } = {}) {
         const result = this._segments.reduce((acc, segment) => {
-            const [path, params] = pathSegmentsBuilder(segment, escape);
+            const [path, params] = pathSegmentsBuilder(segment, escape, parser);
             acc.paths.push(path);
             acc.params = Object.assign(acc.params, params);
             return acc;
@@ -3213,8 +3325,8 @@ class ODataPathSegments {
         }
         return segments.map((s) => s.key());
     }
-    toString() {
-        const [path, params] = this.pathAndParams();
+    toString({ escape, parser, } = {}) {
+        const [path, params] = this.pathAndParams({ escape, parser });
         return (path +
             Object.entries(params)
                 .filter(([, value]) => value)
@@ -3938,12 +4050,7 @@ const EDM_PARSERS = {
     //Edm.Duration Signed duration in days, hours, minutes, and (sub)seconds
     [EdmType.Duration]: EdmParser((v) => Durations.toDuration(v), (v) => Durations.toString(v), (v) => raw(Durations.toString(v))),
     //Edm.Decimal Numeric values with fixed precision and scale
-    [EdmType.Decimal]: EdmParser((v, o) => {
-        if (typeof v === 'string' && o.ieee754Compatible) {
-            return parseFloat(v);
-        }
-        return v;
-    }, (v, o) => {
+    [EdmType.Decimal]: EdmParser(toNumber, (v, o) => {
         if (o.ieee754Compatible) {
             let vstr = v.toPrecision(o.field.precision);
             if (typeof o.field.scale === 'number') {
@@ -4055,7 +4162,7 @@ class ODataEnumTypeParser extends ODataAnnotatable {
         // string | number -> string
         const parserOptions = { ...this.parserOptions, ...options };
         if (this.flags) {
-            let names = Enums.toNames(this.members, value);
+            let names = Enums.toFlags(this.members, value);
             if (names.length === 0)
                 names = [`${value}`];
             return !parserOptions?.stringAsEnum
@@ -4374,6 +4481,9 @@ class ODataStructuredTypeParser extends ODataAnnotatable {
             return this.parent.isSubtypeOf(type);
         return false;
     }
+    isOpenType() {
+        return this.open;
+    }
     findChildParser(predicate) {
         if (predicate(this))
             return this;
@@ -4394,7 +4504,9 @@ class ODataStructuredTypeParser extends ODataAnnotatable {
         const fields = this.fields({
             include_navigation: true,
             include_parents: true,
-        }).filter((f) => f.name in value && value[f.name] !== undefined && value[f.name] !== null);
+        }).filter((f) => f.name in value &&
+            value[f.name] !== undefined &&
+            value[f.name] !== null);
         return {
             ...value,
             ...fields.reduce((acc, f) => ({
@@ -4461,6 +4573,13 @@ class ODataStructuredTypeParser extends ODataAnnotatable {
             ...(this._keys || []),
         ];
     }
+    isEntityType() {
+        return (this._keys !== undefined ||
+            (this.parent !== undefined && this.parent.isEntityType()));
+    }
+    isComplexType() {
+        return !this.isEntityType();
+    }
     /**
      * Find the field parser for the given field name.
      * @param name Name of the field
@@ -4846,14 +4965,13 @@ class ODataStructuredType extends ODataSchemaElement {
         super(config, schema);
         this.children = [];
         this.base = config.base;
-        this.open = config.open || false;
         this.parser = new ODataStructuredTypeParser(config, schema.namespace, schema.alias);
         this.model = config.model;
         this.collection = config.collection;
         if (this.model !== undefined) {
             const options = this.model.hasOwnProperty('options')
                 ? this.model.options
-                : { fields: {} };
+                : { fields: new Map() };
             this.model.buildMeta({ options, schema: this });
         }
         if (this.collection !== undefined) {
@@ -4912,7 +5030,13 @@ class ODataStructuredType extends ODataSchemaElement {
         return this.keys().length > 1;
     }
     isOpenType() {
-        return this.open;
+        return this.parser.isOpenType();
+    }
+    isEntityType() {
+        return this.parser.isEntityType();
+    }
+    isComplexType() {
+        return this.parser.isComplexType();
     }
     /**
      * Find the field parser for the given field name.
@@ -5183,8 +5307,14 @@ class ODataResource {
                 : otherPath === selfPath && Types.isEqual(selfParams, otherParams);
     }
     pathAndParams(escape = false) {
-        const [spath, sparams] = this.pathSegments.pathAndParams(escape);
-        const [, qparams] = this.queryOptions.pathAndParams(escape);
+        const parser = this.schema !== undefined && 'parser' in this.schema
+            ? this.schema.parser
+            : undefined;
+        const [spath, sparams] = this.pathSegments.pathAndParams({
+            escape,
+            parser,
+        });
+        const [, qparams] = this.queryOptions.pathAndParams({ escape, parser });
         return [spath, { ...sparams, ...qparams }];
     }
     endpointUrl(params = true) {
@@ -5196,8 +5326,8 @@ class ODataResource {
             return `${this.api.serviceRootUrl}${path}`;
         }
     }
-    toString() {
-        let [path, params] = this.pathAndParams();
+    toString(escape = false) {
+        let [path, params] = this.pathAndParams(escape);
         let queryString = Object.entries(params)
             .map((e) => `${e[0]}${VALUE_SEPARATOR}${e[1]}`)
             .join(PARAM_SEPARATOR);
@@ -7504,6 +7634,79 @@ class Field {
     }
 }
 class ODataMetadata {
+    // TAGS
+    static { this.TAG_EDMX = 'edmx:Edmx'; }
+    static { this.TAG_DATA_SERVICES = 'edmx:DataServices'; }
+    static { this.TAG_REFERENCE = 'edmx:Reference'; }
+    static { this.TAG_INCLUDE = 'edmx:Include'; }
+    static { this.TAG_INCLUDE_ANNOTATIONS = 'edmx:IncludeAnnotations'; }
+    static { this.TAG_TERM = 'Term'; }
+    static { this.TAG_ANNOTATIONS = 'Annotations'; }
+    static { this.TAG_ANNOTATION = 'Annotation'; }
+    static { this.TAG_SCHEMA = 'Schema'; }
+    static { this.TAG_ENUM_TYPE = 'EnumType'; }
+    static { this.TAG_MEMBER = 'Member'; }
+    static { this.TAG_COMPLEX_TYPE = 'ComplexType'; }
+    static { this.TAG_ENTITY_TYPE = 'EntityType'; }
+    static { this.TAG_PROPERTY = 'Property'; }
+    static { this.TAG_KEY = 'Key'; }
+    static { this.TAG_PROPERTY_REF = 'PropertyRef'; }
+    static { this.TAG_NAVIGATION_PROPERTY = 'NavigationProperty'; }
+    static { this.TAG_REFERENTIAL_CONSTRAINT = 'ReferentialConstraint'; }
+    static { this.TAG_ON_DELETE = 'OnDelete'; }
+    static { this.TAG_FUNCTION = 'Function'; }
+    static { this.TAG_RETURN_TYPE = 'ReturnType'; }
+    static { this.TAG_PARAMETER = 'Parameter'; }
+    static { this.TAG_ACTION = 'Action'; }
+    static { this.TAG_ENTITY_CONTAINER = 'EntityContainer'; }
+    static { this.TAG_ENTITY_SET = 'EntitySet'; }
+    static { this.TAG_SINGLETON = 'Singleton'; }
+    static { this.TAG_FUNCTION_IMPORT = 'FunctionImport'; }
+    static { this.TAG_ACTION_IMPORT = 'ActionImport'; }
+    static { this.TAG_NAVIGATION_PROPERTY_BINDING = 'NavigationPropertyBinding'; }
+    static { this.TAG_TYPE_DEFINITION = 'TypeDefinition'; }
+    // ATTRIBUTES
+    static { this.ATTRIBUTE_VERSION = 'Version'; }
+    static { this.ATTRIBUTE_URI = 'Uri'; }
+    static { this.ATTRIBUTE_ALIAS = 'Alias'; }
+    static { this.ATTRIBUTE_NAMESPACE = 'Namespace'; }
+    static { this.ATTRIBUTE_TERM_NAMESPACE = 'TermNamespace'; }
+    static { this.ATTRIBUTE_QUALIFIER = 'Qualifier'; }
+    static { this.ATTRIBUTE_TARGET_NAMESPACE = 'TargetNamespace'; }
+    static { this.ATTRIBUTE_TERM = 'Term'; }
+    static { this.ATTRIBUTE_NAME = 'Name'; }
+    static { this.ATTRIBUTE_VALUE = 'Value'; }
+    static { this.ATTRIBUTE_BASE_TYPE = 'BaseType'; }
+    static { this.ATTRIBUTE_OPEN_TYPE = 'OpenType'; }
+    static { this.ATTRIBUTE_TYPE = 'Type'; }
+    static { this.ATTRIBUTE_NULLABLE = 'Nullable'; }
+    static { this.ATTRIBUTE_MAX_LENGTH = 'MaxLength'; }
+    static { this.ATTRIBUTE_PRECISION = 'Precision'; }
+    static { this.ATTRIBUTE_SCALE = 'Scale'; }
+    static { this.ATTRIBUTE_UNICODE = 'Unicode'; }
+    static { this.ATTRIBUTE_SRID = 'SRID'; }
+    static { this.ATTRIBUTE_DEFAULT_VALUE = 'DefaultValue'; }
+    static { this.ATTRIBUTE_PARTNER = 'Partner'; }
+    static { this.ATTRIBUTE_PROPERTY = 'Property'; }
+    static { this.ATTRIBUTE_REFERENCED_PROPERTY = 'ReferencedProperty'; }
+    static { this.ATTRIBUTE_HAS_STREAM = 'HasStream'; }
+    static { this.ATTRIBUTE_CONTAINS_TARGET = 'ContainsTarget'; }
+    static { this.ATTRIBUTE_IS_BOUND = 'IsBound'; }
+    static { this.ATTRIBUTE_ENTITY_SET_PATH = 'EntitySetPath'; }
+    static { this.ATTRIBUTE_IS_COMPOSABLE = 'IsComposable'; }
+    static { this.ATTRIBUTE_ENTITY_TYPE = 'EntityType'; }
+    static { this.ATTRIBUTE_PATH = 'Path'; }
+    static { this.ATTRIBUTE_TARGET = 'Target'; }
+    static { this.ATTRIBUTE_FUNCTION = 'Function'; }
+    static { this.ATTRIBUTE_ACTION = 'Action'; }
+    static { this.ATTRIBUTE_ENTITY_SET = 'EntitySet'; }
+    static { this.ATTRIBUTE_INCLUDE_IN_SERVICE_DOCUMENT = 'IncludeInServiceDocument'; }
+    static { this.ATTRIBUTE_ABSTRACT = 'Abstract'; }
+    static { this.ATTRIBUTE_UNDERLYING_TYPE = 'UnderlyingType'; }
+    static { this.ATTRIBUTE_IS_FLAGS = 'IsFlags'; }
+    static { this.ATTRIBUTE_EXTENDS = 'Extends'; }
+    static { this.ATTRIBUTE_BASE_TERM = 'BaseTerm'; }
+    static { this.ATTRIBUTE_APPLIES_TO = 'AppliesTo'; }
     constructor(xml) {
         try {
             const parser = new DOMParser();
@@ -7952,79 +8155,6 @@ class ODataMetadata {
         return attributeValue !== undefined ? attributeValue === 'true' : false;
     }
 }
-// TAGS
-ODataMetadata.TAG_EDMX = 'edmx:Edmx';
-ODataMetadata.TAG_DATA_SERVICES = 'edmx:DataServices';
-ODataMetadata.TAG_REFERENCE = 'edmx:Reference';
-ODataMetadata.TAG_INCLUDE = 'edmx:Include';
-ODataMetadata.TAG_INCLUDE_ANNOTATIONS = 'edmx:IncludeAnnotations';
-ODataMetadata.TAG_TERM = 'Term';
-ODataMetadata.TAG_ANNOTATIONS = 'Annotations';
-ODataMetadata.TAG_ANNOTATION = 'Annotation';
-ODataMetadata.TAG_SCHEMA = 'Schema';
-ODataMetadata.TAG_ENUM_TYPE = 'EnumType';
-ODataMetadata.TAG_MEMBER = 'Member';
-ODataMetadata.TAG_COMPLEX_TYPE = 'ComplexType';
-ODataMetadata.TAG_ENTITY_TYPE = 'EntityType';
-ODataMetadata.TAG_PROPERTY = 'Property';
-ODataMetadata.TAG_KEY = 'Key';
-ODataMetadata.TAG_PROPERTY_REF = 'PropertyRef';
-ODataMetadata.TAG_NAVIGATION_PROPERTY = 'NavigationProperty';
-ODataMetadata.TAG_REFERENTIAL_CONSTRAINT = 'ReferentialConstraint';
-ODataMetadata.TAG_ON_DELETE = 'OnDelete';
-ODataMetadata.TAG_FUNCTION = 'Function';
-ODataMetadata.TAG_RETURN_TYPE = 'ReturnType';
-ODataMetadata.TAG_PARAMETER = 'Parameter';
-ODataMetadata.TAG_ACTION = 'Action';
-ODataMetadata.TAG_ENTITY_CONTAINER = 'EntityContainer';
-ODataMetadata.TAG_ENTITY_SET = 'EntitySet';
-ODataMetadata.TAG_SINGLETON = 'Singleton';
-ODataMetadata.TAG_FUNCTION_IMPORT = 'FunctionImport';
-ODataMetadata.TAG_ACTION_IMPORT = 'ActionImport';
-ODataMetadata.TAG_NAVIGATION_PROPERTY_BINDING = 'NavigationPropertyBinding';
-ODataMetadata.TAG_TYPE_DEFINITION = 'TypeDefinition';
-// ATTRIBUTES
-ODataMetadata.ATTRIBUTE_VERSION = 'Version';
-ODataMetadata.ATTRIBUTE_URI = 'Uri';
-ODataMetadata.ATTRIBUTE_ALIAS = 'Alias';
-ODataMetadata.ATTRIBUTE_NAMESPACE = 'Namespace';
-ODataMetadata.ATTRIBUTE_TERM_NAMESPACE = 'TermNamespace';
-ODataMetadata.ATTRIBUTE_QUALIFIER = 'Qualifier';
-ODataMetadata.ATTRIBUTE_TARGET_NAMESPACE = 'TargetNamespace';
-ODataMetadata.ATTRIBUTE_TERM = 'Term';
-ODataMetadata.ATTRIBUTE_NAME = 'Name';
-ODataMetadata.ATTRIBUTE_VALUE = 'Value';
-ODataMetadata.ATTRIBUTE_BASE_TYPE = 'BaseType';
-ODataMetadata.ATTRIBUTE_OPEN_TYPE = 'OpenType';
-ODataMetadata.ATTRIBUTE_TYPE = 'Type';
-ODataMetadata.ATTRIBUTE_NULLABLE = 'Nullable';
-ODataMetadata.ATTRIBUTE_MAX_LENGTH = 'MaxLength';
-ODataMetadata.ATTRIBUTE_PRECISION = 'Precision';
-ODataMetadata.ATTRIBUTE_SCALE = 'Scale';
-ODataMetadata.ATTRIBUTE_UNICODE = 'Unicode';
-ODataMetadata.ATTRIBUTE_SRID = 'SRID';
-ODataMetadata.ATTRIBUTE_DEFAULT_VALUE = 'DefaultValue';
-ODataMetadata.ATTRIBUTE_PARTNER = 'Partner';
-ODataMetadata.ATTRIBUTE_PROPERTY = 'Property';
-ODataMetadata.ATTRIBUTE_REFERENCED_PROPERTY = 'ReferencedProperty';
-ODataMetadata.ATTRIBUTE_HAS_STREAM = 'HasStream';
-ODataMetadata.ATTRIBUTE_CONTAINS_TARGET = 'ContainsTarget';
-ODataMetadata.ATTRIBUTE_IS_BOUND = 'IsBound';
-ODataMetadata.ATTRIBUTE_ENTITY_SET_PATH = 'EntitySetPath';
-ODataMetadata.ATTRIBUTE_IS_COMPOSABLE = 'IsComposable';
-ODataMetadata.ATTRIBUTE_ENTITY_TYPE = 'EntityType';
-ODataMetadata.ATTRIBUTE_PATH = 'Path';
-ODataMetadata.ATTRIBUTE_TARGET = 'Target';
-ODataMetadata.ATTRIBUTE_FUNCTION = 'Function';
-ODataMetadata.ATTRIBUTE_ACTION = 'Action';
-ODataMetadata.ATTRIBUTE_ENTITY_SET = 'EntitySet';
-ODataMetadata.ATTRIBUTE_INCLUDE_IN_SERVICE_DOCUMENT = 'IncludeInServiceDocument';
-ODataMetadata.ATTRIBUTE_ABSTRACT = 'Abstract';
-ODataMetadata.ATTRIBUTE_UNDERLYING_TYPE = 'UnderlyingType';
-ODataMetadata.ATTRIBUTE_IS_FLAGS = 'IsFlags';
-ODataMetadata.ATTRIBUTE_EXTENDS = 'Extends';
-ODataMetadata.ATTRIBUTE_BASE_TERM = 'BaseTerm';
-ODataMetadata.ATTRIBUTE_APPLIES_TO = 'AppliesTo';
 
 class ODataMetadataResource extends ODataResource {
     constructor(api, segments) {
@@ -8272,12 +8402,12 @@ class ODataModelEvent {
     }
     get path() {
         return this.chain
-            .map(([, field], index) => typeof field === 'number'
-            ? `[${field}]`
-            : field instanceof ODataModelField
+            .map(([, attr], index) => typeof attr === 'number'
+            ? `[${attr}]`
+            : attr instanceof ODataModelAttribute
                 ? index === 0
-                    ? field.name
-                    : `.${field.name}`
+                    ? attr.name
+                    : `.${attr.name}`
                 : '')
             .join('');
     }
@@ -8322,7 +8452,9 @@ function Model({ cid = CID_FIELD_NAME } = {}) {
     return (constructor) => {
         const Klass = constructor;
         if (!Klass.hasOwnProperty('options'))
-            Klass.options = { fields: {} };
+            Klass.options = {
+                fields: new Map(),
+            };
         Klass.options.cid = cid;
         return constructor;
     };
@@ -8331,9 +8463,11 @@ function ModelField({ name, ...options } = {}) {
     return (target, key) => {
         const Klass = target.constructor;
         if (!Klass.hasOwnProperty('options'))
-            Klass.options = { fields: {} };
+            Klass.options = {
+                fields: new Map(),
+            };
         options.field = name || key;
-        Klass.options.fields[key] = options;
+        Klass.options.fields.set(key, options);
     };
 }
 class ODataModelField {
@@ -8556,9 +8690,7 @@ class ODataModelAttribute {
         const current = this.get();
         if (ODataModelOptions.isModel(current) ||
             ODataModelOptions.isCollection(current))
-            this.unlink(current
-            //this.value !== current
-            );
+            this.unlink(current);
         const changed = ODataModelOptions.isModel(current) && ODataModelOptions.isModel(value)
             ? !current.equals(value)
             : ODataModelOptions.isCollection(current) &&
@@ -8623,10 +8755,9 @@ class ODataModelOptions {
         };
         this.name = schema.name;
         this.base = schema.base;
-        this.open = schema.open;
         this.schema = schema;
         this.cid = options?.cid || CID_FIELD_NAME;
-        Object.entries(options.fields).forEach(([name, options]) => this.addField(name, options));
+        options.fields.forEach((value, key) => this.addField(key, value));
     }
     get api() {
         return this.schema.api;
@@ -8637,6 +8768,12 @@ class ODataModelOptions {
     isOpenType() {
         return this.schema.isOpenType();
     }
+    isEntityType() {
+        return this.schema.isEntityType();
+    }
+    isComplexType() {
+        return this.schema.isComplexType();
+    }
     isTypeOf(type) {
         return this.schema.isTypeOf(type);
     }
@@ -9325,6 +9462,15 @@ class ODataModelOptions {
 }
 
 class ODataCollection {
+    static { this.model = null; }
+    models() {
+        return this._entries
+            .filter((e) => e.state !== ODataModelState.Removed)
+            .map((e) => e.model);
+    }
+    get length() {
+        return this.models().length;
+    }
     constructor(entities = [], { parent, resource, annots, model, reset = false, } = {}) {
         this._parent = null;
         this._resource = null;
@@ -9356,14 +9502,6 @@ class ODataCollection {
         entities = entities || [];
         this.assign(entities, { reset });
     }
-    models() {
-        return this._entries
-            .filter((e) => e.state !== ODataModelState.Removed)
-            .map((e) => e.model);
-    }
-    get length() {
-        return this.models().length;
-    }
     isParentOf(child) {
         return (child !== this &&
             ODataModelOptions.chain(child).some((p) => p[0] === this));
@@ -9922,6 +10060,8 @@ class ODataCollection {
                     if (model.hasChanged())
                         toChange.push([model, position]);
                 }
+                if (reset)
+                    entry.state = ODataModelState.Unchanged;
                 // Has Sort or Index Change?
                 if (toSort.length > 0 || position !== this.models().indexOf(model)) {
                     toSort.push([model, position]);
@@ -9931,12 +10071,14 @@ class ODataCollection {
                 // Add
                 model = isModel
                     ? obj
-                    : this.modelFactory(obj);
+                    : this.modelFactory(obj, {
+                        reset,
+                    });
                 toAdd.push([model, position]);
             }
             modelMap.push(model[Model.meta.cid]);
         });
-        if (remove) {
+        if (remove || reset) {
             this._entries.forEach((entry, position) => {
                 if (modelMap.indexOf(entry.model[Model.meta.cid]) === -1)
                     toRemove.push([entry.model, position]);
@@ -10175,17 +10317,39 @@ class ODataCollection {
         }
     }
 }
-ODataCollection.model = null;
 
 // @dynamic
 class ODataModel {
+    static buildMeta({ options, schema, }) {
+        if (options === undefined) {
+            let fields = schema
+                .fields({ include_navigation: true, include_parents: true })
+                .reduce((acc, field) => {
+                let name = field.name;
+                // Prevent collision with reserved keywords
+                while (RESERVED_FIELD_NAMES.includes(name)) {
+                    name = name + '_';
+                }
+                return Object.assign(acc, {
+                    [name]: {
+                        field: field.name,
+                        default: field.default,
+                        required: !field.nullable,
+                    },
+                });
+            }, {});
+            options = {
+                fields: new Map(Object.entries(fields)),
+            };
+        }
+        this.meta = new ODataModelOptions({ options, schema });
+    }
     constructor(data = {}, { parent, resource, annots, reset = false, } = {}) {
         // Parent
         this._parent = null;
         this._resource = null;
         this._resources = [];
         this._attributes = new Map();
-        this._annotations = null;
         this._reset = false;
         this._reparent = false;
         this._silent = false;
@@ -10206,28 +10370,6 @@ class ODataModel {
             reset,
         });
     }
-    static buildMeta({ options, schema, }) {
-        if (options === undefined) {
-            let fields = schema
-                .fields({ include_navigation: true, include_parents: true })
-                .reduce((acc, field) => {
-                let name = field.name;
-                // Prevent collision with reserved keywords
-                while (RESERVED_FIELD_NAMES.includes(name)) {
-                    name = name + '_';
-                }
-                return Object.assign(acc, {
-                    [name]: {
-                        field: field.name,
-                        default: field.default,
-                        required: !field.nullable,
-                    },
-                });
-            }, {});
-            options = { fields };
-        }
-        this.meta = new ODataModelOptions({ options, schema });
-    }
     //#region Resources
     resource() {
         return ODataModelOptions.resource(this);
@@ -10276,8 +10418,7 @@ class ODataModel {
         return this._meta.schema;
     }
     annots() {
-        return (this._annotations ??
-            new ODataEntityAnnotations(ODataHelper[DEFAULT_VERSION]));
+        return this._annotations;
     }
     key({ field_mapping = false, resolve = true, } = {}) {
         return this._meta.resolveKey(this, { field_mapping, resolve });
@@ -10502,6 +10643,13 @@ class ODataModel {
     hasChanged({ include_navigation = false, } = {}) {
         return this._meta.hasChanged(this, { include_navigation });
     }
+    encode(name, options) {
+        let value = this[name];
+        if (value === undefined)
+            return undefined;
+        let field = this._meta.field(name);
+        return field !== undefined ? field.encode(value, options) : value;
+    }
     isNew() {
         return !this._meta.hasKey(this);
     }
@@ -10516,6 +10664,7 @@ class ODataModel {
     asEntity(ctx) {
         return this._meta.asEntity(this, ctx);
     }
+    //#region Callables
     callFunction(name, params, responseType, { ...options } = {}) {
         const resource = this.resource();
         if (!(resource instanceof ODataEntityResource) || !resource.hasKey())
@@ -10556,6 +10705,7 @@ class ODataModel {
                 return action.call(params, { responseType, ...options });
         }
     }
+    //#endregion
     // Cast
     cast(type) {
         //: ODataModel<S> {
@@ -10600,7 +10750,7 @@ class ODataModel {
         }
         return of(value);
     }
-    // Set Reference
+    //#region References
     setReference(name, model, options) {
         const reference = this.navigationProperty(name).reference();
         const etag = this.annots().etag;
@@ -10646,20 +10796,41 @@ class ODataModel {
         }
         return model;
     }
-    // Model functions
-    equals(other) {
-        const thisKey = this.key();
-        const otherKey = other.key();
-        return (this === other ||
-            (typeof this === typeof other &&
-                (this[this._meta.cid] === other[this._meta.cid] ||
-                    (thisKey !== undefined &&
-                        otherKey !== undefined &&
-                        Types.isEqual(thisKey, otherKey)))));
-    }
+    //#endregion
+    //#region Model Identity
     get [Symbol.toStringTag]() {
         return 'Model';
     }
+    equals(other) {
+        if (this === other)
+            return true;
+        if (typeof this !== typeof other)
+            return false;
+        const meta = this._meta;
+        const thisCid = this[meta.cid];
+        const otherCid = other[meta.cid];
+        if (thisCid !== undefined &&
+            otherCid !== undefined &&
+            Types.isEqual(thisCid, otherCid))
+            return true;
+        if (meta.isEntityType()) {
+            const thisKey = this.key();
+            const otherKey = other.key();
+            if (thisKey !== undefined &&
+                otherKey !== undefined &&
+                Types.isEqual(thisKey, otherKey))
+                return true;
+        }
+        else if (meta.isComplexType()) {
+            const thisJson = this.toJSON();
+            const otherJson = other.toJSON();
+            if (Types.isEqual(thisJson, otherJson))
+                return true;
+        }
+        return false;
+    }
+    //#endregion
+    //#region Collection Tools
     collection() {
         return this._parent !== null &&
             ODataModelOptions.isCollection(this._parent[0])
@@ -11543,10 +11714,10 @@ class ODataClient {
     put(resource, body, options = {}) {
         return this.request('PUT', resource, addBody(options, body));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: ODataConfigLoader }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataClient }); }
 }
-ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataClient, deps: [{ token: i1.HttpClient }, { token: ODataConfigLoader }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataClient });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataClient, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataClient, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: ODataConfigLoader }]; } });
 
@@ -11798,10 +11969,10 @@ class ODataServiceFactory {
         return new (class extends ODataSingletonService {
         })(this.client, singletonName, apiNameOrEntityType);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataServiceFactory }); }
 }
-ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataServiceFactory });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataServiceFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataServiceFactory, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: ODataClient }]; } });
 
@@ -11828,11 +11999,11 @@ class ODataModule {
             ],
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.3", ngImport: i0, type: ODataModule, imports: [CommonModule, HttpClientModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [CommonModule, HttpClientModule] }); }
 }
-ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.6", ngImport: i0, type: ODataModule, imports: [CommonModule, HttpClientModule] });
-ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [CommonModule, HttpClientModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: ODataModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: ODataModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule, HttpClientModule],
@@ -11848,5 +12019,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { BUBBLING, Dates, Durations, EDM_PARSERS, EdmType, Enums, Http, INCLUDE_DEEP, INCLUDE_SHALLOW, ITEM_ROOT, Model, ModelField, NONE_PARSER, ODATA_CONFIG, OData, ODataActionResource, ODataAnnotations, ODataApi, ODataBaseService, ODataBatchRequest, ODataBatchResource, ODataCache, ODataCallable, ODataCallableParser, ODataClient, ODataCollection, ODataConfigAsyncLoader, ODataConfigLoader, ODataConfigSyncLoader, ODataCountResource, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityContainer, ODataEntityResource, ODataEntitySet, ODataEntitySetResource, ODataEntitySetService, ODataEntityTypeKey, ODataEnumType, ODataEnumTypeFieldParser, ODataEnumTypeParser, ODataFunctionResource, ODataInMemoryCache, ODataInStorageCache, ODataMediaResource, ODataMetadata, ODataMetadataResource, ODataModel, ODataModelAttribute, ODataModelEvent, ODataModelEventType, ODataModelField, ODataModelOptions, ODataModelState, ODataModule, ODataNavigationPropertyResource, ODataParameterParser, ODataPathSegments, ODataPathSegmentsHandler, ODataPropertyAnnotations, ODataPropertyResource, ODataQueryOptionHandler, ODataQueryOptions, ODataQueryOptionsHandler, ODataReferenceResource, ODataReferential, ODataRequest, ODataResource, ODataResponse, ODataSchema, ODataServiceFactory, ODataSettings, ODataSingletonResource, ODataSingletonService, ODataStructuredType, ODataStructuredTypeFieldParser, ODataStructuredTypeParser, ODataValueResource, Objects, PathSegment, QueryCustomTypes, QueryOption, RESERVED_FIELD_NAMES, SegmentHandler, StandardAggregateMethods, Strings, Types, Urls, alias, binary, buildPathAndQuery, createSyncLoader, duration, isQueryCustomType, normalizeValue, raw };
+export { BUBBLING, Dates, Durations, EDM_PARSERS, EdmType, Enums, Http, INCLUDE_DEEP, INCLUDE_SHALLOW, ITEM_ROOT, Model, ModelField, NONE_PARSER, ODATA_CONFIG, OData, ODataActionResource, ODataAnnotations, ODataApi, ODataBaseService, ODataBatchRequest, ODataBatchResource, ODataCache, ODataCallable, ODataCallableParser, ODataClient, ODataCollection, ODataConfigAsyncLoader, ODataConfigLoader, ODataConfigSyncLoader, ODataCountResource, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityContainer, ODataEntityResource, ODataEntitySet, ODataEntitySetResource, ODataEntitySetService, ODataEntityTypeKey, ODataEnumType, ODataEnumTypeFieldParser, ODataEnumTypeParser, ODataFunctionResource, ODataInMemoryCache, ODataInStorageCache, ODataMediaResource, ODataMetadata, ODataMetadataResource, ODataModel, ODataModelAttribute, ODataModelEvent, ODataModelEventType, ODataModelField, ODataModelOptions, ODataModelState, ODataModule, ODataNavigationPropertyResource, ODataParameterParser, ODataPathSegments, ODataPathSegmentsHandler, ODataPropertyAnnotations, ODataPropertyResource, ODataQueryOptionHandler, ODataQueryOptions, ODataQueryOptionsHandler, ODataReferenceResource, ODataReferential, ODataRequest, ODataResource, ODataResponse, ODataSchema, ODataServiceFactory, ODataSettings, ODataSingletonResource, ODataSingletonService, ODataStructuredType, ODataStructuredTypeFieldParser, ODataStructuredTypeParser, ODataValueResource, Objects, PathSegment, QueryCustomTypes, QueryOption, RESERVED_FIELD_NAMES, SegmentHandler, StandardAggregateMethods, Strings, Types, Urls, alias, binary, buildPathAndQuery, createSyncLoader, duration, isQueryCustomType, isRawType, normalizeValue, raw };
 //# sourceMappingURL=angular-odata.mjs.map