angular-odata 0.92.0 → 0.95.0

package/fesm2015/{angular-odata.js → angular-odata.mjs}

@@ -119,6 +119,8 @@ const ODATA_ALIAS_PREFIX = '@';
 const NEWLINE = '\r\n';
 const NEWLINE_REGEXP = /\r?\n/;
 const CACHE_KEY_SEPARATOR = ':';
+// Models
+const CID_FIELD_NAME = '_cid';
 // Standard vocabularies for annotating OData services
 // http://docs.oasis-open.org/odata/odata-vocabularies/v4.0/csprd01/odata-vocabularies-v4.0-csprd01.html
 const COMPUTED = /.*Computed$/;
@@ -1376,11 +1378,12 @@ const Objects = {
 const OData = {
     // Merge callables parameters
     mergeCallableParameters(callables) {
+        const areEqual = (a, b) => a.name === b.name &&
+            Objects.equal((a.parameters || {})[CALLABLE_BINDING_PARAMETER] || {}, (b.parameters || {})[CALLABLE_BINDING_PARAMETER] || {});
         return callables.reduce((acc, config) => {
-            if (acc.every((c) => c.name !== config.name)) {
+            if (acc.every((c) => !areEqual(c, config))) {
                 config = callables
-                    .filter((c) => c.name === config.name &&
-                    Objects.equal((c.parameters || {})[CALLABLE_BINDING_PARAMETER] || {}, (config.parameters || {})[CALLABLE_BINDING_PARAMETER] || {}))
+                    .filter((c) => areEqual(c, config))
                     .reduce((acc, c) => {
                     acc.parameters = Object.assign(acc.parameters || {}, c.parameters || {});
                     return acc;
@@ -1435,6 +1438,24 @@ const Urls = {
     },
 };
 
+//export type Field<T> = keyof T | Funcs<keyof T>;
+class Field$1 {
+    constructor(name = '') {
+        this.name = name;
+    }
+    static factory() {
+        const h = new Field$1();
+        return new Proxy({ _name: '' }, h);
+    }
+    get(target, p) {
+        let name = target['_name'];
+        if (p === 'render') {
+            return ({ prefix }) => prefix ? `${prefix}/${name}` : name;
+        }
+        name = name ? `${name}/${p}` : p;
+        return new Proxy({ _name: name }, this);
+    }
+}
 function applyMixins(derivedCtor, constructors) {
     constructors.forEach((baseCtor) => {
         Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
@@ -1443,15 +1464,18 @@ function applyMixins(derivedCtor, constructors) {
         });
     });
 }
-function render(value, { aliases, normalize, escape, } = {}) {
+function render(value, { aliases, normalize, escape, prefix, } = {}) {
     if (typeof value === 'function') {
-        return render(value(syntax), { aliases, normalize });
+        return render(value(syntax), { aliases, normalize, prefix });
     }
-    if (typeof value === 'object' && value !== null && 'render' in value) {
-        return render(value.render({ aliases, escape }), {
+    if (typeof value === 'object' &&
+        value !== null &&
+        value.render !== undefined) {
+        return render(value.render({ aliases, escape, prefix }), {
             aliases,
             normalize,
             escape,
+            prefix,
         });
     }
     return normalize ? normalizeValue(value, { aliases, escape }) : value;
@@ -1473,12 +1497,12 @@ class Function {
             normalize: this.normalize,
         };
     }
-    render({ aliases, escape, }) {
+    render({ aliases, escape, prefix, }) {
         let [field, ...values] = this.values;
-        field = render(field);
+        field = render(field, { aliases, escape, prefix });
         let params = [
             field,
-            ...values.map((v) => render(v, { aliases, escape, normalize: this.normalize })),
+            ...values.map((v) => render(v, { aliases, escape, prefix, normalize: this.normalize })),
         ];
         return `${this.name}(${params.join(', ')})`;
     }
@@ -1627,21 +1651,23 @@ class Operator {
             normalize: this.normalize,
         };
     }
-    render({ aliases, escape, }) {
+    render({ aliases, escape, prefix, }) {
         let [left, right] = this.values;
-        left = render(left, { aliases, escape });
+        left = render(left, { aliases, escape, prefix });
         if (right !== undefined) {
             right = Array.isArray(right)
                 ? `(${right
                     .map((v) => render(v, {
                     aliases,
                     escape,
+                    prefix,
                     normalize: this.normalize,
                 }))
                     .join(',')})`
                 : render(right, {
                     aliases,
                     escape,
+                    prefix,
                     normalize: this.normalize,
                 });
             return `${left} ${this.op} ${right}`;
@@ -1668,12 +1694,14 @@ class LogicalOperators {
     le(left, right, normalize) {
         return new Operator('le', [left, right], normalize);
     }
-    and(left, right, normalize) {
-        return new Operator('and', [left, right], normalize);
+    /*
+    and(left: any, right: any, normalize?: boolean) {
+      return new Operator('and', [left, right], normalize);
     }
-    or(left, right, normalize) {
-        return new Operator('or', [left, right], normalize);
+    or(left: any, right: any, normalize?: boolean) {
+      return new Operator('or', [left, right], normalize);
     }
+    */
     not(value, normalize) {
         return new Operator('not', [value], normalize);
     }
@@ -1716,62 +1744,76 @@ class Grouping {
             group: this.group.toJSON(),
         };
     }
-    render({ aliases, escape, }) {
-        return `(${render(this.group, { aliases })})`;
+    render({ aliases, escape, prefix, }) {
+        return `(${render(this.group, { aliases, escape, prefix })})`;
     }
 }
-class Navigation {
-    constructor(field, value) {
-        this.field = field;
-        this.value = value;
-    }
-    get [Symbol.toStringTag]() {
-        return 'Navigation';
-    }
-    toJSON() {
-        return {
-            field: this.field,
-            value: this.value,
-        };
-    }
-    render({ aliases, escape, }) {
-        return `${this.field}/${render(this.value, { aliases, escape })}`;
-    }
+/*
+export class Navigation<T, N> implements Renderable {
+  constructor(protected field: T, protected value: Field<N>) {}
+
+  get [Symbol.toStringTag]() {
+    return 'Navigation';
+  }
+
+  toJSON() {
+    return {
+      field: this.field,
+      value: this.value,
+    };
+  }
+
+  render({
+    aliases,
+    escape,
+    prefix,
+  }: {
+    aliases?: QueryCustomType[];
+    escape?: boolean;
+    prefix?: string;
+  }): string {
+    return `${this.field}/${render(this.value, { aliases, escape, prefix })}`;
+  }
 }
-class GroupingAndNavigationOperators {
+*/
+class GroupingOperators {
     grouping(value) {
         return new Grouping(value);
     }
-    navigation(field, value) {
-        return new Navigation(field, value);
-    }
 }
-class Lambda extends Operator {
-    constructor(op, values, normalize = true) {
-        super(op, values, normalize);
+class Lambda {
+    constructor(op, values, alias) {
         this.op = op;
         this.values = values;
-        this.normalize = normalize;
+        this.alias = alias;
     }
     get [Symbol.toStringTag]() {
         return 'Lambda';
     }
-    render({ aliases, escape, }) {
+    toJSON() {
+        return {
+            op: this.op,
+            values: this.values,
+            alias: this.alias,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
         let [left, right] = this.values;
-        left = render(left, { aliases, escape });
-        let alias = left.split('/').pop().toLowerCase();
-        return `${left}/${this.op}(${alias}:${alias}/${render(right, {
+        left = render(left, { aliases, escape, prefix });
+        let alias = this.alias || left.split('/').pop().toLowerCase()[0];
+        return `${left}/${this.op}(${alias}:${render(right, {
             aliases,
             escape,
+            prefix: alias,
         })})`;
     }
 }
 class LambdaOperators {
-    any(field, value) {
-        return new Lambda('any', [field, value]);
+    any(field, value, alias) {
+        return new Lambda('any', [field, value], alias);
     }
-    all(field, value) {
-        return new Lambda('all', [field, value]);
+    all(field, value, alias) {
+        return new Lambda('all', [field, value], alias);
     }
 }
 class ODataOperators {
@@ -1779,7 +1821,7 @@ class ODataOperators {
 applyMixins(ODataOperators, [
     LogicalOperators,
     ArithmeticOperators,
-    GroupingAndNavigationOperators,
+    GroupingOperators,
     LambdaOperators,
 ]);
 const operators = new ODataOperators();
@@ -1801,34 +1843,33 @@ class ODataSyntax {
 applyMixins(ODataSyntax, [ODataOperators, ODataFunctions]);
 const syntax = new ODataSyntax();
 
-var Connector;
-(function (Connector) {
-    Connector["AND"] = "and";
-    Connector["OR"] = "or";
-})(Connector || (Connector = {}));
 class Expression {
     constructor({ children, connector, negated, } = {}) {
         this._children = children || [];
-        this._connector = connector || Connector.AND;
+        this._connector = connector || 'and';
         this._negated = negated || false;
     }
     get [Symbol.toStringTag]() {
         return 'Expression';
     }
-    static e() {
-        return new Expression({ connector: Connector.AND });
+    static s() {
+        return Field$1.factory();
     }
-    static and() {
-        return new Expression({ connector: Connector.AND });
+    static e(connector = 'and') {
+        return new Expression({ connector });
     }
-    static or() {
-        return new Expression({ connector: Connector.OR });
+    static o() {
+        return operators;
     }
-    static not(exp) {
-        return new Expression({
-            children: exp.children(),
-            connector: exp.connector(),
-            negated: true,
+    static f() {
+        return functions;
+    }
+    static filter(opts) {
+        return opts({
+            s: Expression.s(),
+            e: Expression.e,
+            o: Expression.o(),
+            f: Expression.f(),
         });
     }
     toJSON() {
@@ -1850,9 +1891,9 @@ class Expression {
     length() {
         return this._children.length;
     }
-    render({ aliases, escape, } = {}) {
+    render({ aliases, escape, prefix, } = {}) {
         let content = this._children
-            .map((n) => n.render({ aliases, escape }))
+            .map((n) => n.render({ aliases, escape, prefix }))
             .join(` ${this._connector} `);
         if (this._negated) {
             content = `not (${content})`;
@@ -1903,52 +1944,65 @@ class Expression {
         return this;
     }
     or(exp) {
-        return this._add(typeof exp === 'function' ? exp(new Expression()) : exp, Connector.OR);
+        return this._add(exp, 'or');
     }
     and(exp) {
-        return this._add(typeof exp === 'function' ? exp(new Expression()) : exp, Connector.AND);
+        return this._add(exp, 'and');
     }
     not(exp) {
-        return this._add(Expression.not(typeof exp === 'function' ? exp(new Expression()) : exp), this._connector);
+        const notExp = new Expression({
+            children: exp.children(),
+            connector: exp.connector(),
+            negated: true,
+        });
+        return this._add(notExp, this._connector);
     }
     eq(left, right, normalize) {
-        return this._add(syntax.eq(left, right, normalize));
+        return this._add(operators.eq(left, right, normalize));
     }
     ne(left, right, normalize) {
-        return this._add(syntax.ne(left, right, normalize));
+        return this._add(operators.ne(left, right, normalize));
     }
     gt(left, right, normalize) {
-        return this._add(syntax.gt(left, right, normalize));
+        return this._add(operators.gt(left, right, normalize));
     }
     ge(left, right, normalize) {
-        return this._add(syntax.ge(left, right, normalize));
+        return this._add(operators.ge(left, right, normalize));
     }
     lt(left, right, normalize) {
-        return this._add(syntax.lt(left, right, normalize));
+        return this._add(operators.lt(left, right, normalize));
     }
     le(left, right, normalize) {
-        return this._add(syntax.le(left, right, normalize));
+        return this._add(operators.le(left, right, normalize));
     }
     has(left, right, normalize) {
-        return this._add(syntax.has(left, right, normalize));
+        return this._add(operators.has(left, right, normalize));
     }
     in(left, right, normalize) {
-        return this._add(syntax.in(left, right, normalize));
+        return this._add(operators.in(left, right, normalize));
     }
     contains(left, right, normalize) {
-        return this._add(syntax.contains(left, right, normalize));
+        return this._add(functions.contains(left, right, normalize));
     }
     startsWith(left, right, normalize) {
-        return this._add(syntax.startsWith(left, right, normalize));
+        return this._add(functions.startsWith(left, right, normalize));
     }
     endsWith(left, right, normalize) {
-        return this._add(syntax.endsWith(left, right, normalize));
+        return this._add(functions.endsWith(left, right, normalize));
     }
-    any(left, exp) {
-        return this._add(syntax.any(left, typeof exp === 'function' ? exp(new Expression()) : exp));
+    any(left, opts, alias) {
+        const exp = opts({
+            s: Field$1.factory(),
+            e: Expression.e,
+        });
+        return this._add(syntax.any(left, exp, alias));
     }
-    all(left, exp) {
-        return this._add(syntax.all(left, typeof exp === 'function' ? exp(new Expression()) : exp));
+    all(left, opts, alias) {
+        const exp = opts({
+            s: Field$1.factory(),
+            e: Expression.e,
+        });
+        return this._add(syntax.all(left, exp, alias));
     }
     isof(left, type) {
         return this._add(syntax.isof(left, type));
@@ -2099,9 +2153,6 @@ class ODataQueryOptionsHandler {
         if (Types.isFunction(opts)) {
             return this.options.expression(QueryOptionNames.compute, opts({
                 e: () => Expression.e(),
-                and: () => Expression.and(),
-                or: () => Expression.or(),
-                not: (e) => Expression.not(e),
             }));
         }
         return this.options.option(QueryOptionNames.compute, opts);
@@ -2118,10 +2169,10 @@ class ODataQueryOptionsHandler {
     filter(opts) {
         if (Types.isFunction(opts)) {
             return this.options.expression(QueryOptionNames.filter, opts({
-                e: () => Expression.e(),
-                and: () => Expression.and(),
-                or: () => Expression.or(),
-                not: (e) => Expression.not(e),
+                s: Expression.s(),
+                e: Expression.e,
+                o: Expression.o(),
+                f: Expression.f(),
             }));
         }
         return this.options.option(QueryOptionNames.filter, opts);
@@ -2130,9 +2181,6 @@ class ODataQueryOptionsHandler {
         if (Types.isFunction(opts)) {
             return this.options.expression(QueryOptionNames.orderBy, opts({
                 e: () => Expression.e(),
-                and: () => Expression.and(),
-                or: () => Expression.or(),
-                not: (e) => Expression.not(e),
             }));
         }
         return this.options.option(QueryOptionNames.orderBy, opts);
@@ -2670,6 +2718,55 @@ class ODataAnnotatable {
     }
 }
 
+class ODataSchemaElement extends ODataAnnotatable {
+    constructor(config, schema) {
+        super(config);
+        this.schema = schema;
+        this.name = config.name;
+    }
+    get api() {
+        return this.schema.api;
+    }
+    /**
+     * Create a nicer looking title.
+     * Titleize is meant for creating pretty output.
+     * @param term The term of the annotation to find.
+     * @returns The titleized string.
+     */
+    titleize(term) {
+        return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
+    }
+    /**
+     * Returns a full type of the structured type including the namespace/alias.
+     * @param alias Use the alias of the namespace instead of the namespace.
+     * @returns The string representation of the type.
+     */
+    type({ alias = false } = {}) {
+        return `${alias ? this.schema.alias : this.schema.namespace}.${this.name}`;
+    }
+    /**
+     * Returns a boolean indicating if the structured type is of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isTypeOf(type) {
+        var names = [`${this.schema.namespace}.${this.name}`];
+        if (this.schema.alias)
+            names.push(`${this.schema.alias}.${this.name}`);
+        return names.indexOf(type) !== -1;
+    }
+    /**
+     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSubtypeOf(schema) {
+        if (this.isTypeOf(schema.type()))
+            return true;
+        return false;
+    }
+}
+
 //https://github.com/niklasvh/base64-arraybuffer
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 // Use a lookup table to find the index.
@@ -3089,6 +3186,7 @@ class ODataApiOptions {
         this.accept = config.accept;
         Object.assign(this.etag, config.etag || {});
         this.prefer = config.prefer;
+        this.deleteRefBy = config.deleteRefBy || 'path';
     }
     get helper() {
         return ODataHelper[this.version];
@@ -3111,7 +3209,7 @@ class ODataEnumTypeFieldParser extends ODataAnnotatable {
         this.value = field.value;
     }
     titleize(term) {
-        return this.annotatedValue(term) || this.name;
+        return (term && this.annotatedValue(term)) || this.name;
     }
 }
 class ODataEnumTypeParser extends ODataAnnotatable {
@@ -3130,8 +3228,8 @@ class ODataEnumTypeParser extends ODataAnnotatable {
      * @param term The term of the annotation to find.
      * @returns The titleized string.
      */
-    titelize(term) {
-        return this.annotatedValue(term) || Strings.titleCase(this.name);
+    ttitelize(term) {
+        return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
     }
     configure({ options }) {
         this.optionsHelper = options;
@@ -3435,8 +3533,8 @@ class ODataStructuredTypeParser extends ODataAnnotatable {
      * @param term The term of the annotation to find.
      * @returns The titleized string.
      */
-    titelize(term) {
-        return this.annotatedValue(term) || Strings.titleCase(this.name);
+    titleize(term) {
+        return (term && this.annotatedValue(term)) || Strings.titleCase(this.name);
     }
     isTypeOf(type) {
         var names = [`${this.namespace}.${this.name}`];
@@ -3444,11 +3542,12 @@ class ODataStructuredTypeParser extends ODataAnnotatable {
             names.push(`${this.alias}.${this.name}`);
         return names.indexOf(type) !== -1;
     }
-    typeFor(name) {
-        const field = this.fields.find((f) => f.name === name);
-        if (field === undefined && this.parent !== undefined)
-            return this.parent.typeFor(name);
-        return field !== undefined ? field.type : undefined;
+    isSubtypeOf(type) {
+        if (this.isTypeOf(type))
+            return true;
+        if (this.parent)
+            return this.parent.isSubtypeOf(type);
+        return false;
     }
     findChildParser(predicate) {
         if (predicate(this))
@@ -3547,7 +3646,7 @@ class ODataStructuredTypeParser extends ODataAnnotatable {
         let schema = ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.toJsonSchema(options)) || {
             $schema: 'http://json-schema.org/draft-07/schema#',
             $id: `${this.namespace}.${this.name}`,
-            title: this.titelize(DESCRIPTION),
+            title: this.titleize(DESCRIPTION),
             description: this.annotatedValue(LONG_DESCRIPTION),
             type: 'object',
             properties: {},
@@ -3694,10 +3793,9 @@ class ODataCallableParser {
     }
 }
 
-class ODataCallable {
+class ODataCallable extends ODataSchemaElement {
     constructor(config, schema) {
-        this.schema = schema;
-        this.name = config.name;
+        super(config, schema);
         this.entitySetPath = config.entitySetPath;
         this.bound = config.bound;
         this.composable = config.composable;
@@ -3717,25 +3815,6 @@ class ODataCallable {
                 : this.name;
         return path;
     }
-    /**
-     * Returns a full type of the callable including the namespace/alias.
-     * @param alias Use the alias of the namespace instead of the namespace.
-     * @returns The string representation of the type.
-     */
-    type({ alias = false } = {}) {
-        return `${alias ? this.schema.alias : this.schema.namespace}.${this.name}`;
-    }
-    /**
-     * Returns a boolean indicating if the callable is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(type) {
-        return this.parser.isTypeOf(type);
-    }
-    get api() {
-        return this.schema.api;
-    }
     configure({ parserForType, }) {
         this.parser.configure({ options: this.api.options, parserForType });
     }
@@ -3775,96 +3854,27 @@ class ODataCallable {
     }
 }
 
-class ODataEntitySet extends ODataAnnotatable {
+class ODataEntitySet extends ODataSchemaElement {
     constructor(config, schema) {
-        super(config);
-        this.schema = schema;
-        this.name = config.name;
+        super(config, schema);
         this.entityType = config.entityType;
         this.service = config.service;
     }
-    /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    titelize(term) {
-        return this.annotatedValue(term) || Strings.titleCase(this.name);
-    }
-    /**
-     * Returns a boolean indicating if the entity set is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(type) {
-        var names = [`${this.schema.namespace}.${this.name}`];
-        if (this.schema.alias)
-            names.push(`${this.schema.alias}.${this.name}`);
-        return names.indexOf(type) !== -1;
-    }
-    get api() {
-        return this.schema.api;
-    }
 }
 
-class ODataEntityContainer extends ODataAnnotatable {
+class ODataEntityContainer extends ODataSchemaElement {
     constructor(config, schema) {
-        super(config);
-        this.schema = schema;
-        this.name = config.name;
+        super(config, schema);
         this.entitySets = (config.entitySets || []).map((config) => new ODataEntitySet(config, schema));
     }
-    get api() {
-        return this.schema.api;
-    }
-    /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    titelize(term) {
-        return this.annotatedValue(term) || Strings.titleCase(this.name);
-    }
 }
 
-class ODataEnumType extends ODataAnnotatable {
+class ODataEnumType extends ODataSchemaElement {
     constructor(config, schema) {
-        super(config);
-        this.schema = schema;
-        this.name = config.name;
+        super(config, schema);
         this.members = config.members;
         this.parser = new ODataEnumTypeParser(config, schema.namespace, schema.alias);
     }
-    /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    titelize(term) {
-        return this.annotatedValue(term) || Strings.titleCase(this.name);
-    }
-    /**
-     * Returns a full type of the enum type including the namespace/alias.
-     * @param alias Use the alias of the namespace instead of the namespace.
-     * @returns The string representation of the type.
-     */
-    type({ alias = false } = {}) {
-        return `${alias ? this.schema.alias : this.schema.namespace}.${this.name}`;
-    }
-    /**
-     * Returns a boolean indicating if the enum type is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(type) {
-        return this.parser.isTypeOf(type);
-    }
-    get api() {
-        return this.schema.api;
-    }
     configure() {
         this.parser.configure({ options: this.api.options });
     }
@@ -3928,12 +3938,10 @@ class ODataEnumType extends ODataAnnotatable {
     }
 }
 
-class ODataStructuredType extends ODataAnnotatable {
+class ODataStructuredType extends ODataSchemaElement {
     constructor(config, schema) {
-        super(config);
+        super(config, schema);
         this.children = [];
-        this.schema = schema;
-        this.name = config.name;
         this.base = config.base;
         this.open = config.open || false;
         this.parser = new ODataStructuredTypeParser(config, schema.namespace, schema.alias);
@@ -3943,15 +3951,12 @@ class ODataStructuredType extends ODataAnnotatable {
             const options = this.model.hasOwnProperty('options')
                 ? this.model.options
                 : { fields: {} };
-            this.model.buildMeta(options, this);
+            this.model.buildMeta({ options, schema: this });
         }
         if (this.collection !== undefined) {
             this.collection.model = this.model;
         }
     }
-    get api() {
-        return this.schema.api;
-    }
     configure({ parserForType, findOptionsForType, }) {
         if (this.base) {
             const parent = this.api.findStructuredTypeForType(this.base);
@@ -3967,29 +3972,13 @@ class ODataStructuredType extends ODataAnnotatable {
         }
     }
     /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    titelize(term) {
-        return this.annotatedValue(term) || Strings.titleCase(this.name);
-    }
-    /**
-     * Returns a full type of the structured type including the namespace/alias.
-     * @param alias Use the alias of the namespace instead of the namespace.
-     * @returns The string representation of the type.
-     */
-    type({ alias = false } = {}) {
-        return `${alias ? this.schema.alias : this.schema.namespace}.${this.name}`;
-    }
-    /**
-     * Returns a boolean indicating if the structured type is of the given type.
+     * Returns a boolean indicating if the structured type is a sub type of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
-    isTypeOf(type) {
-        return this.parser.isTypeOf(type);
+    isSubtypeOf(schema) {
+        return (super.isSubtypeOf(schema) ||
+            (this.parent !== undefined && this.parent.isSubtypeOf(schema)));
     }
     /**
      * Returns a boolean indicating if the structured type has a simple key.
@@ -4171,10 +4160,20 @@ class ODataSchema extends ODataAnnotatable {
         return this.entities.find((e) => e.isTypeOf(type));
     }
     findCallableForType(type, bindingType) {
+        const bindingStructuredType = bindingType !== undefined
+            ? this.api.findStructuredTypeForType(bindingType)
+            : undefined;
         return this.callables.find((c) => {
             var _a;
-            return c.isTypeOf(type) &&
-                (bindingType === undefined || bindingType === ((_a = c.binding()) === null || _a === void 0 ? void 0 : _a.type));
+            const isCallableType = c.isTypeOf(type);
+            const callableBindingType = (_a = c.binding()) === null || _a === void 0 ? void 0 : _a.type;
+            const callableBindingStructuredType = callableBindingType !== undefined
+                ? this.api.findStructuredTypeForType(callableBindingType)
+                : undefined;
+            return (isCallableType &&
+                (!bindingStructuredType ||
+                    (callableBindingStructuredType &&
+                        bindingStructuredType.isSubtypeOf(callableBindingStructuredType))));
         });
     }
     findEntitySetForType(type) {
@@ -4192,10 +4191,11 @@ class ODataSchema extends ODataAnnotatable {
 }
 
 class ODataResource {
-    constructor(api, segments, query) {
+    constructor(api, { segments, query, schema, } = {}) {
         this.api = api;
         this.pathSegments = segments || new ODataPathSegments();
         this.queryOptions = query || new ODataQueryOptions();
+        this.schema = schema;
     }
     /**
      * @returns string The type of the resource
@@ -4228,28 +4228,53 @@ class ODataResource {
         var _a;
         return (_a = this.pathSegments.last({ key: true })) === null || _a === void 0 ? void 0 : _a.clearKey();
     }
+    //#region Models
+    asModel(entity, { annots, reset } = {}) {
+        let resource = this;
+        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.returnType();
+        if (type === undefined)
+            throw Error('');
+        const Model = this.api.modelForType(type);
+        let entitySet = annots === null || annots === void 0 ? void 0 : annots.entitySet;
+        if (entitySet !== undefined) {
+            resource = this.api.entitySet(entitySet).entity(entity);
+            resource.query((q) => q.apply(this.queryOptions.toQueryArguments()));
+        }
+        return new Model(entity, { resource, annots, reset });
+    }
+    asCollection(entities, { annots, reset, } = {}) {
+        let resource = this;
+        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.returnType();
+        if (type === undefined)
+            throw Error('');
+        const Collection = this.api.collectionForType(type);
+        let path = annots === null || annots === void 0 ? void 0 : annots.entitySet;
+        if (path !== undefined) {
+            resource = this.api.entitySet(path);
+            resource.query((q) => q.apply(this.queryOptions.toQueryArguments()));
+        }
+        return new Collection(entities, { resource, annots, reset });
+    }
+    //#endregion
     isSubtypeOf(other) {
         var _a;
-        const api = this.api;
-        const selfType = this.type();
-        const otherType = other.type();
-        if (selfType !== undefined && otherType !== undefined) {
-            const otherParser = (_a = other.schema()) === null || _a === void 0 ? void 0 : _a.parser;
-            return (otherParser !== undefined &&
-                otherParser.findChildParser((c) => c.isTypeOf(selfType)) !== undefined);
-        }
-        return false;
+        return (this.schema !== undefined &&
+            other.schema !== undefined &&
+            ((_a = this.schema) === null || _a === void 0 ? void 0 : _a.isSubtypeOf(other.schema)));
     }
-    isParentOf(other) {
-        const [selfPath] = this.pathAndParams();
-        const [otherPath] = other.pathAndParams();
-        return otherPath !== selfPath && otherPath.startsWith(selfPath);
+    /*
+    isParentOf(other: ODataResource<any>) {
+      const [selfPath] = this.pathAndParams();
+      const [otherPath] = other.pathAndParams();
+      return otherPath !== selfPath && otherPath.startsWith(selfPath);
     }
-    isChildOf(other) {
-        const [selfPath] = this.pathAndParams();
-        const [otherPath] = other.pathAndParams();
-        return otherPath !== selfPath && selfPath.startsWith(otherPath);
+  
+    isChildOf(other: ODataResource<any>) {
+      const [selfPath] = this.pathAndParams();
+      const [otherPath] = other.pathAndParams();
+      return otherPath !== selfPath && selfPath.startsWith(otherPath);
     }
+    */
     isEqualTo(other, test) {
         const [selfPath, selfParams] = this.pathAndParams();
         const [otherPath, otherParams] = other.pathAndParams();
@@ -4280,11 +4305,37 @@ class ODataResource {
             .join(PARAM_SEPARATOR);
         return queryString ? `${path}${QUERY_SEPARATOR}${queryString}` : path;
     }
+    clone() {
+        const Ctor = this.constructor;
+        return new Ctor(this.api, {
+            schema: this.schema,
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
+    }
     deserialize(value, options) {
-        const baseType = this.returnType();
+        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 type = (Types.isPlainObject(value) && options.helper.type(value)) || baseType;
-            const parser = type !== undefined ? this.api.parserForType(type) : undefined;
+            const parser = _p(value, options);
             return parser !== undefined && 'deserialize' in parser
                 ? parser.deserialize(value, options)
                 : value;
@@ -4294,10 +4345,28 @@ class ODataResource {
             : _d(value, options || this.api.options);
     }
     serialize(value, options) {
-        const baseType = this.type();
+        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 type = (Types.isPlainObject(value) && options.helper.type(value)) || baseType;
-            const parser = type !== undefined ? this.api.parserForType(type) : undefined;
+            const parser = _p(value, options);
             return parser !== undefined && 'serialize' in parser
                 ? parser.serialize(value, options)
                 : value;
@@ -4307,10 +4376,28 @@ class ODataResource {
             : _s(value, options || this.api.options);
     }
     encode(value, options) {
-        const baseType = this.type();
+        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 type = (Types.isPlainObject(value) && options.helper.type(value)) || baseType;
-            const parser = type !== undefined ? this.api.parserForType(type) : undefined;
+            const parser = _p(value, options);
             return parser !== undefined && 'encode' in parser
                 ? parser.encode(value, options)
                 : value;
@@ -4366,7 +4453,7 @@ class ODataResource {
         return value;
     }
     resolveKey(value) {
-        return ODataResource.resolveKey(value, this.schema());
+        return ODataResource.resolveKey(value, this.schema);
     }
     //#endregion
     // Base Requests
@@ -4429,49 +4516,45 @@ class ODataResource {
 
 class ODataActionResource extends ODataResource {
     //#region Factory
-    static factory(api, path, type, segments, query) {
+    static factory(api, { path, schema, segments, query, }) {
+        segments = segments || new ODataPathSegments();
+        path = schema !== undefined ? schema.path() : path;
+        if (path === undefined)
+            throw new Error(`ODataActionResource: path is required`);
         const segment = segments.add(PathSegmentNames.action, path);
-        if (type)
-            segment.type(type);
-        query.clear();
-        return new ODataActionResource(api, segments, query);
-    }
-    clone() {
-        return new ODataActionResource(this.api, this.cloneSegments(), this.cloneQuery());
-    }
-    //#endregion
-    schema() {
-        //TODO: Binding Type
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findCallableForType(type)
-            : undefined;
-    }
-    returnType() {
-        var _a, _b;
-        return (_b = (_a = this.schema()) === null || _a === void 0 ? void 0 : _a.parser.return) === null || _b === void 0 ? void 0 : _b.type;
-    }
-    asModel(entity, { annots, reset } = {}) {
-        let resource;
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.returnType();
-        const Model = this.api.modelForType(type);
-        let path = annots === null || annots === void 0 ? void 0 : annots.entitySet;
-        if (path !== undefined) {
-            resource = this.api.entitySet(path).entity(entity);
-            resource.query((q) => q.apply(this.queryOptions.toQueryArguments()));
-        }
-        return new Model(entity, { resource, annots, reset });
-    }
-    asCollection(entities, { annots, reset, } = {}) {
-        let resource;
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.returnType();
-        const Collection = this.api.collectionForType(type);
-        let path = annots === null || annots === void 0 ? void 0 : annots.entitySet;
-        if (path !== undefined) {
-            resource = this.api.entitySet(path);
-            resource.query((q) => q.apply(this.queryOptions.toQueryArguments()));
+        if (schema !== undefined)
+            segment.type(schema.type());
+        return new ODataActionResource(api, {
+            segments,
+            query,
+            schema,
+        });
+    }
+    static fromResource(resource, path) {
+        var _a;
+        const baseType = resource.type();
+        const actionSchema = resource.api.findCallableForType(path, baseType);
+        const bindingType = (_a = actionSchema === null || actionSchema === void 0 ? void 0 : actionSchema.binding()) === null || _a === void 0 ? void 0 : _a.type;
+        const action = ODataActionResource.factory(resource.api, {
+            path,
+            schema: actionSchema,
+            segments: resource.cloneSegments(),
+        });
+        // Switch entitySet to binding type if available
+        if (bindingType !== undefined && bindingType !== baseType) {
+            let entitySet = resource.api.findEntitySetForType(bindingType);
+            if (entitySet !== undefined) {
+                action.segment((s) => s.entitySet().path(entitySet.name));
+            }
         }
-        return new Collection(entities, { resource, annots, reset });
+        return action;
+    }
+    //#endregion
+    returnType() {
+        var _a;
+        return this.schema instanceof ODataCallable
+            ? (_a = this.schema.parser.return) === null || _a === void 0 ? void 0 : _a.type
+            : undefined;
     }
     //#region Requests
     post(params, options) {
@@ -5772,15 +5855,9 @@ class ODataBatchResource extends ODataResource {
     static factory(api) {
         let segments = new ODataPathSegments();
         segments.add(PathSegmentNames.batch, $BATCH);
-        return new ODataBatchResource(api, segments);
-    }
-    clone() {
-        return new ODataBatchResource(this.api, this.cloneSegments());
+        return new ODataBatchResource(api, { segments });
     }
     //#endregion
-    schema() {
-        return undefined;
-    }
     /**
      * Execute the batch request
      * @param ctx The context for the request
@@ -5949,18 +6026,12 @@ class ODataBatchResource extends ODataResource {
 
 class ODataCountResource extends ODataResource {
     //#region Factory
-    static factory(api, segments, query) {
+    static factory(api, { segments, query, }) {
         segments.add(PathSegmentNames.count, $COUNT).type('Edm.Int32');
-        query.keep(QueryOptionNames.filter, QueryOptionNames.search);
-        return new ODataCountResource(api, segments, query);
-    }
-    clone() {
-        return new ODataCountResource(this.api, this.cloneSegments(), this.cloneQuery());
+        query === null || query === void 0 ? void 0 : query.keep(QueryOptionNames.filter, QueryOptionNames.search);
+        return new ODataCountResource(api, { segments, query });
     }
     //#endregion
-    schema() {
-        return undefined;
-    }
     //#region Requests
     get(options) {
         return super.get(Object.assign({ responseType: 'value' }, options));
@@ -5979,61 +6050,56 @@ class ODataCountResource extends ODataResource {
 
 class ODataFunctionResource extends ODataResource {
     //#region Factory
-    static factory(api, path, type, segments, options) {
+    static factory(api, { path, schema, segments, query, }) {
+        segments = segments || new ODataPathSegments();
+        path = schema !== undefined ? schema.path() : path;
+        if (path === undefined)
+            throw new Error(`ODataActionResource: path is required`);
         const segment = segments.add(PathSegmentNames.function, path);
-        if (type)
-            segment.type(type);
-        options.clear();
-        return new ODataFunctionResource(api, segments, options);
+        if (schema !== undefined)
+            segment.type(schema.type());
+        return new ODataFunctionResource(api, {
+            segments,
+            query,
+            schema,
+        });
     }
-    clone() {
-        return new ODataFunctionResource(this.api, this.cloneSegments(), this.cloneQuery());
+    static fromResource(resource, path) {
+        var _a;
+        const baseType = resource.type();
+        const schema = resource.api.findCallableForType(path, baseType);
+        const bindingType = (_a = schema === null || schema === void 0 ? void 0 : schema.binding()) === null || _a === void 0 ? void 0 : _a.type;
+        const func = ODataFunctionResource.factory(resource.api, {
+            path,
+            schema,
+            segments: resource.cloneSegments(),
+        });
+        // Switch entitySet to binding type if available
+        if (bindingType !== undefined && bindingType !== baseType) {
+            let entitySet = resource.api.findEntitySetForType(bindingType);
+            if (entitySet !== undefined) {
+                func.segment((s) => s.entitySet().path(entitySet.name));
+            }
+        }
+        return func;
     }
     //#endregion
     returnType() {
-        var _a, _b;
-        return (_b = (_a = this.schema()) === null || _a === void 0 ? void 0 : _a.parser.return) === null || _b === void 0 ? void 0 : _b.type;
-    }
-    schema() {
-        //TODO: Binding Type
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findCallableForType(type)
+        var _a;
+        return this.schema instanceof ODataCallable
+            ? (_a = this.schema.parser.return) === null || _a === void 0 ? void 0 : _a.type
             : undefined;
     }
-    asModel(entity, { annots, reset } = {}) {
-        let resource;
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.returnType();
-        const Model = this.api.modelForType(type);
-        let path = annots === null || annots === void 0 ? void 0 : annots.entitySet;
-        if (path !== undefined) {
-            resource = this.api.entitySet(path).entity(entity);
-            resource.query((q) => q.apply(this.queryOptions.toQueryArguments()));
-        }
-        return new Model(entity, { resource, annots, reset });
-    }
-    asCollection(entities, { annots, reset, } = {}) {
-        let resource;
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.returnType();
-        const Collection = this.api.collectionForType(type);
-        let path = annots === null || annots === void 0 ? void 0 : annots.entitySet;
-        if (path !== undefined) {
-            resource = this.api.entitySet(path);
-            resource.query((q) => q.apply(this.queryOptions.toQueryArguments()));
-        }
-        return new Collection(entities, { resource, annots, reset });
-    }
-    parameters(params, { alias: alias$1 } = {}) {
-        const segments = this.cloneSegments();
-        const segment = segments.get(PathSegmentNames.function);
+    parameters(params, { alias } = {}) {
         let parameters = params !== null ? this.encode(params) : null;
-        if (alias$1 && parameters !== null) {
-            parameters = Object.entries(parameters).reduce((acc, [name, param]) => {
-                return Object.assign(acc, { [name]: alias(param, name) });
-            }, {});
+        if (alias && parameters !== null) {
+            this.query((q) => {
+                parameters = Object.entries(parameters).reduce((acc, [name, param]) => {
+                    return Object.assign(acc, { [name]: q.alias(param, name) });
+                }, {});
+            });
         }
-        segment.parameters(parameters);
-        return new ODataFunctionResource(this.api, segments, this.cloneQuery());
+        return this.clone().segment((s) => s.function().parameters(parameters));
     }
     //#region Requests
     get(options) {
@@ -6104,17 +6170,11 @@ class ODataFunctionResource extends ODataResource {
 
 class ODataMediaResource extends ODataResource {
     //#region Factory
-    static factory(api, segments, options) {
+    static factory(api, { segments, query, }) {
         segments.add(PathSegmentNames.value, $VALUE);
-        return new ODataMediaResource(api, segments, options);
-    }
-    clone() {
-        return new ODataMediaResource(this.api, this.cloneSegments(), this.cloneQuery());
+        return new ODataMediaResource(api, { segments, query });
     }
     //#endregion
-    schema() {
-        return undefined;
-    }
     //#region Requests
     get(options) {
         return super.get(options);
@@ -6147,20 +6207,26 @@ class ODataMediaResource extends ODataResource {
 
 class ODataValueResource extends ODataResource {
     //#region Factory
-    static factory(api, type, segments, options) {
+    static factory(api, { type, schema, segments, query, }) {
+        const baseType = type;
+        const bindingType = schema === null || schema === void 0 ? void 0 : schema.type();
         const segment = segments.add(PathSegmentNames.value, $VALUE);
-        if (type)
+        if (schema !== undefined)
+            segment.type(schema.type());
+        else if (type !== undefined)
             segment.type(type);
-        options.clear();
-        return new ODataValueResource(api, segments, options);
-    }
-    clone() {
-        return new ODataValueResource(this.api, this.cloneSegments(), this.cloneQuery());
+        query === null || query === void 0 ? void 0 : query.clear();
+        const value = new ODataValueResource(api, { segments, query, schema });
+        // Switch entitySet to binding type if available
+        if (bindingType !== undefined && bindingType !== baseType) {
+            let entitySet = api.findEntitySetForType(bindingType);
+            if (entitySet !== undefined) {
+                value.segment((s) => s.entitySet().path(entitySet.name));
+            }
+        }
+        return value;
     }
     //#endregion
-    schema() {
-        return undefined;
-    }
     //#region Requests
     get(options) {
         return super.get(Object.assign({ responseType: 'value' }, options));
@@ -6179,33 +6245,53 @@ class ODataValueResource extends ODataResource {
 
 class ODataPropertyResource extends ODataResource {
     //#region Factory
-    static factory(api, path, type, segments, options) {
+    static factory(api, { path, type, schema, segments, query, }) {
         const segment = segments.add(PathSegmentNames.property, path);
-        if (type)
+        if (schema !== undefined)
+            segment.type(schema.type());
+        else if (type !== undefined)
             segment.type(type);
-        options.clear();
-        return new ODataPropertyResource(api, segments, options);
+        query === null || query === void 0 ? void 0 : query.clear();
+        return new ODataPropertyResource(api, {
+            segments,
+            query,
+            schema,
+        });
     }
-    clone() {
-        return new ODataPropertyResource(this.api, this.cloneSegments(), this.cloneQuery());
+    static fromResource(resource, path) {
+        const baseType = resource.type();
+        let baseSchema = resource.schema;
+        let fieldType;
+        let fieldSchema;
+        if (baseSchema !== undefined) {
+            const field = baseSchema.findFieldByName(path);
+            fieldType = field === null || field === void 0 ? void 0 : field.type;
+            fieldSchema =
+                fieldType !== undefined
+                    ? resource.api.findStructuredTypeForType(fieldType)
+                    : undefined;
+            baseSchema =
+                field !== undefined
+                    ? baseSchema.findSchemaForField(field)
+                    : undefined;
+        }
+        const property = ODataPropertyResource.factory(resource.api, {
+            path,
+            type: fieldType,
+            schema: fieldSchema,
+            segments: resource.cloneSegments(),
+            query: resource.cloneQuery(),
+        });
+        // Switch entitySet to binding type if available
+        if (baseSchema !== undefined && baseSchema.type() !== baseType) {
+            let entitySet = resource.api.findEntitySetForType(baseSchema.type());
+            if (entitySet !== undefined) {
+                property.segment((s) => s.entitySet().path(entitySet.name));
+            }
+        }
+        return property;
     }
     //#endregion
-    schema() {
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findStructuredTypeForType(type)
-            : undefined;
-    }
-    asModel(entity, { annots, reset } = {}) {
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.type();
-        const Model = this.api.modelForType(type);
-        return new Model(entity, { resource: this, annots, reset });
-    }
-    asCollection(entities, { annots, reset, } = {}) {
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.type();
-        const Collection = this.api.collectionForType(type);
-        return new Collection(entities, { resource: this, annots, reset });
-    }
     key(value) {
         const property = this.clone();
         var key = this.resolveKey(value);
@@ -6221,37 +6307,49 @@ class ODataPropertyResource extends ODataResource {
         return property;
     }
     value() {
-        return ODataValueResource.factory(this.api, this.type(), this.cloneSegments(), this.cloneQuery());
+        return ODataValueResource.factory(this.api, {
+            type: this.returnType(),
+            schema: this.schema,
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
     }
     /*
     navigationProperty<N>(path: string) {
-      let type = this.type();
-      if (type !== undefined) {
-        let parser = this.api.parserForType<N>(type);
-        type =
-          parser instanceof ODataStructuredTypeParser
-            ? parser.typeFor(path)
+      let schema: ODataStructuredType<N> | undefined;
+      if (this.schema instanceof ODataStructuredType) {
+        const field = this.schema.findFieldByName<any>(path as keyof T);
+        schema =
+          field !== undefined
+            ? this.schema.findSchemaForField<N>(field)
             : undefined;
       }
-      return ODataNavigationPropertyResource.factory<N>(
-        this.api,
+      return ODataNavigationPropertyResource.factory<N>(this.api, {
         path,
-        type,
-        this.cloneSegments(),
-        this.cloneQuery<N>()
-      );
+        schema,
+        segments: this.cloneSegments(),
+        query: this.cloneQuery<N>(),
+      });
     }
     */
     property(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
+        let type;
+        let schema;
+        if (this.schema instanceof ODataStructuredType) {
+            const field = this.schema.findFieldByName(path);
+            type = field === null || field === void 0 ? void 0 : field.type;
+            schema =
+                field !== undefined
+                    ? this.schema.findSchemaForField(field)
                     : undefined;
         }
-        return ODataPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataPropertyResource.factory(this.api, {
+            path,
+            type,
+            schema,
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
     }
     //#region Requests
     get(options) {
@@ -6323,18 +6421,12 @@ class ODataPropertyResource extends ODataResource {
 
 class ODataReferenceResource extends ODataResource {
     //#region Factory
-    static factory(api, segments, options) {
+    static factory(api, { segments, query, }) {
         segments.add(PathSegmentNames.reference, $REF);
-        options.clear();
-        return new ODataReferenceResource(api, segments, options);
-    }
-    clone() {
-        return new ODataReferenceResource(this.api, this.cloneSegments(), this.cloneQuery());
+        query === null || query === void 0 ? void 0 : query.clear();
+        return new ODataReferenceResource(api, { segments, query });
     }
     //#endregion
-    schema() {
-        return undefined;
-    }
     //#region Requests
     post(target, options) {
         return super.post({ [ODATA_ID]: target.endpointUrl(false) }, options);
@@ -6342,7 +6434,6 @@ class ODataReferenceResource extends ODataResource {
     put(target, options) {
         return super.put({ [ODATA_ID]: target.endpointUrl(false) }, options);
     }
-    //TODO: https://github.com/OData/AspNetCoreOData/blob/08b00758dac691b28aa675f5aa3522fc1caa089e/sample/ODataRoutingSample/Controllers/v1/OrganizationsController.cs#L178
     delete(_a = {}) {
         var { etag, target } = _a, options = __rest(_a, ["etag", "target"]);
         if (target) {
@@ -6389,6 +6480,25 @@ class ODataReferenceResource extends ODataResource {
     unset(options) {
         return this.delete(options);
     }
+    fetch(options = {}) {
+        return this.get(options);
+    }
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
+    fetchEntity(options = {}) {
+        return this.fetch(Object.assign({ responseType: 'entity' }, options)).pipe(map(({ entity }) => entity));
+    }
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options = {}) {
+        return this.fetch(Object.assign({ responseType: 'entities' }, options)).pipe(map(({ entities }) => entities));
+    }
 }
 
 /**
@@ -6398,33 +6508,53 @@ class ODataReferenceResource extends ODataResource {
  */
 class ODataNavigationPropertyResource extends ODataResource {
     //#region Factory
-    static factory(api, path, type, segments, options) {
+    static factory(api, { path, type, schema, segments, query, }) {
         const segment = segments.add(PathSegmentNames.navigationProperty, path);
-        if (type)
+        if (schema !== undefined)
+            segment.type(schema.type());
+        else if (type !== undefined)
             segment.type(type);
-        options.keep(QueryOptionNames.format);
-        return new ODataNavigationPropertyResource(api, segments, options);
+        query === null || query === void 0 ? void 0 : query.keep(QueryOptionNames.format);
+        return new ODataNavigationPropertyResource(api, {
+            segments,
+            query,
+            schema,
+        });
     }
-    clone() {
-        return new ODataNavigationPropertyResource(this.api, this.cloneSegments(), this.cloneQuery());
+    static fromResource(resource, path) {
+        const baseType = resource.type();
+        let baseSchema = resource.schema;
+        let fieldType;
+        let fieldSchema;
+        if (baseSchema !== undefined) {
+            const field = baseSchema.findFieldByName(path);
+            fieldType = field === null || field === void 0 ? void 0 : field.type;
+            fieldSchema =
+                fieldType !== undefined
+                    ? resource.api.findStructuredTypeForType(fieldType)
+                    : undefined;
+            baseSchema =
+                field !== undefined
+                    ? baseSchema.findSchemaForField(field)
+                    : undefined;
+        }
+        const navigation = ODataNavigationPropertyResource.factory(resource.api, {
+            path,
+            type: fieldType,
+            schema: fieldSchema,
+            segments: resource.cloneSegments(),
+            query: resource.cloneQuery(),
+        });
+        // Switch entitySet to binding type if available
+        if (baseSchema !== undefined && baseSchema.type() !== baseType) {
+            let entitySet = resource.api.findEntitySetForType(baseSchema.type());
+            if (entitySet !== undefined) {
+                navigation.segment((s) => s.entitySet().path(entitySet.name));
+            }
+        }
+        return navigation;
     }
     //#endregion
-    schema() {
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findStructuredTypeForType(type)
-            : undefined;
-    }
-    asModel(entity, { annots, reset } = {}) {
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.type();
-        const Model = this.api.modelForType(type);
-        return new Model(entity, { resource: this, annots, reset });
-    }
-    asCollection(entities, { annots, reset, } = {}) {
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.type();
-        const Collection = this.api.collectionForType(type);
-        return new Collection(entities, { resource: this, annots, reset });
-    }
     key(value) {
         const navigation = this.clone();
         var key = this.resolveKey(value);
@@ -6440,40 +6570,42 @@ class ODataNavigationPropertyResource extends ODataResource {
         return navigation;
     }
     media() {
-        return ODataMediaResource.factory(this.api, this.cloneSegments(), this.cloneQuery());
+        return ODataMediaResource.factory(this.api, {
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
     }
     reference() {
-        return ODataReferenceResource.factory(this.api, this.cloneSegments(), this.cloneQuery());
+        return ODataReferenceResource.factory(this.api, {
+            segments: this.cloneSegments(),
+        });
     }
     navigationProperty(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
-                    : undefined;
-        }
-        return ODataNavigationPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataNavigationPropertyResource.fromResource(this, path);
     }
     property(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
-                    : undefined;
-        }
-        return ODataPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataPropertyResource.fromResource(this, path);
     }
     count() {
-        return ODataCountResource.factory(this.api, this.cloneSegments(), this.cloneQuery());
+        return ODataCountResource.factory(this.api, {
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
     }
     cast(type) {
-        let segments = this.cloneSegments();
+        const baseSchema = this.schema;
+        const castSchema = this.api.findStructuredTypeForType(type);
+        if (castSchema !== undefined &&
+            baseSchema !== undefined &&
+            !castSchema.isSubtypeOf(baseSchema))
+            throw new Error(`Cannot cast to ${type}`);
+        const segments = this.cloneSegments();
         segments.add(PathSegmentNames.type, type).type(type);
-        return new ODataNavigationPropertyResource(this.api, segments, this.cloneQuery());
+        return new ODataNavigationPropertyResource(this.api, {
+            segments,
+            schema: castSchema,
+            query: this.cloneQuery(),
+        });
     }
     //#region Requests
     post(attrs, options = {}) {
@@ -6589,25 +6721,11 @@ class ODataNavigationPropertyResource extends ODataResource {
 
 class ODataEntityResource extends ODataResource {
     //#region Factory
-    static factory(api, segments, options) {
-        options.keep(QueryOptionNames.expand, QueryOptionNames.select, QueryOptionNames.format);
-        return new ODataEntityResource(api, segments, options);
-    }
-    clone() {
-        return new ODataEntityResource(this.api, this.cloneSegments(), this.cloneQuery());
+    static factory(api, { schema, segments, query, }) {
+        query === null || query === void 0 ? void 0 : query.keep(QueryOptionNames.expand, QueryOptionNames.select, QueryOptionNames.format);
+        return new ODataEntityResource(api, { segments, query, schema });
     }
     //#endregion
-    schema() {
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findStructuredTypeForType(type)
-            : undefined;
-    }
-    asModel(entity, { annots, reset } = {}) {
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.type();
-        const Model = this.api.modelForType(type);
-        return new Model(entity, { resource: this, annots, reset });
-    }
     key(value) {
         const entity = this.clone();
         var key = this.resolveKey(value);
@@ -6623,53 +6741,37 @@ class ODataEntityResource extends ODataResource {
         return entity;
     }
     media() {
-        return ODataMediaResource.factory(this.api, this.cloneSegments(), this.cloneQuery());
+        return ODataMediaResource.factory(this.api, {
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
     }
     navigationProperty(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
-                    : undefined;
-        }
-        return ODataNavigationPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataNavigationPropertyResource.fromResource(this, path);
     }
     property(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
-                    : undefined;
-        }
-        return ODataPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataPropertyResource.fromResource(this, path);
     }
     action(path) {
-        let type;
-        const callable = this.api.findCallableForType(path, this.type());
-        if (callable !== undefined) {
-            path = callable.path();
-            type = callable.type();
-        }
-        return ODataActionResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataActionResource.fromResource(this, path);
     }
     function(path) {
-        let type;
-        const callable = this.api.findCallableForType(path, this.type());
-        if (callable !== undefined) {
-            path = callable.path();
-            type = callable.type();
-        }
-        return ODataFunctionResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataFunctionResource.fromResource(this, path);
     }
-    //TODO: Check
     cast(type) {
-        let segments = this.cloneSegments();
+        const baseSchema = this.schema;
+        const castSchema = this.api.findStructuredTypeForType(type);
+        if (castSchema !== undefined &&
+            baseSchema !== undefined &&
+            !castSchema.isSubtypeOf(baseSchema))
+            throw new Error(`Cannot cast to ${type}`);
+        const segments = this.cloneSegments();
         segments.add(PathSegmentNames.type, type).type(type);
-        return new ODataEntityResource(this.api, segments, this.cloneQuery());
+        return new ODataEntityResource(this.api, {
+            segments,
+            schema: castSchema,
+            query: this.cloneQuery(),
+        });
     }
     //#region Requests
     post(attrs, options = {}) {
@@ -6716,59 +6818,51 @@ class ODataEntityResource extends ODataResource {
 
 class ODataEntitySetResource extends ODataResource {
     //#region Factory
-    static factory(api, path, type, segments, query) {
+    static factory(api, { path, schema, query, }) {
+        const segments = new ODataPathSegments();
         const segment = segments.add(PathSegmentNames.entitySet, path);
-        if (type)
-            segment.type(type);
-        return new ODataEntitySetResource(api, segments, query);
-    }
-    clone() {
-        return new ODataEntitySetResource(this.api, this.cloneSegments(), this.cloneQuery());
+        if (schema !== undefined)
+            segment.type(schema.type());
+        return new ODataEntitySetResource(api, { segments, query, schema });
     }
     //#endregion
-    schema() {
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findStructuredTypeForType(type)
-            : undefined;
-    }
-    asCollection(entities, { annots, reset = false, } = {}) {
-        const type = (annots === null || annots === void 0 ? void 0 : annots.type) || this.type();
-        const Collection = this.api.collectionForType(type);
-        return new Collection(entities, { resource: this, annots, reset });
-    }
     entity(key) {
-        const entity = ODataEntityResource.factory(this.api, this.cloneSegments(), this.cloneQuery());
+        const entity = ODataEntityResource.factory(this.api, {
+            schema: this.schema,
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
         if (key !== undefined) {
             return entity.key(key);
         }
         return entity;
     }
-    cast(type) {
-        let segments = this.cloneSegments();
-        segments.add(PathSegmentNames.type, type).type(type);
-        return new ODataEntitySetResource(this.api, segments, this.cloneQuery());
-    }
     action(path) {
-        let type;
-        const callable = this.api.findCallableForType(path, this.type());
-        if (callable !== undefined) {
-            path = callable.path();
-            type = callable.type();
-        }
-        return ODataActionResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataActionResource.fromResource(this, path);
     }
     function(path) {
-        let type;
-        const callable = this.api.findCallableForType(path, this.type());
-        if (callable !== undefined) {
-            path = callable.path();
-            type = callable.type();
-        }
-        return ODataFunctionResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataFunctionResource.fromResource(this, path);
     }
     count() {
-        return ODataCountResource.factory(this.api, this.cloneSegments(), this.cloneQuery());
+        return ODataCountResource.factory(this.api, {
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
+    }
+    cast(type) {
+        const baseSchema = this.schema;
+        const castSchema = this.api.findStructuredTypeForType(type);
+        if (castSchema !== undefined &&
+            baseSchema !== undefined &&
+            !castSchema.isSubtypeOf(baseSchema))
+            throw new Error(`Cannot cast to ${type}`);
+        const segments = this.cloneSegments();
+        segments.add(PathSegmentNames.type, type).type(type);
+        return new ODataEntitySetResource(this.api, {
+            segments,
+            schema: castSchema,
+            query: this.cloneQuery(),
+        });
     }
     //#region Requests
     post(attrs, options = {}) {
@@ -6809,7 +6903,7 @@ class ODataEntitySetResource extends ODataResource {
 
 class ODataMetadataResource extends ODataResource {
     constructor(api, segments) {
-        super(api, segments);
+        super(api, { segments });
     }
     //#region Factory
     static factory(api) {
@@ -6817,13 +6911,7 @@ class ODataMetadataResource extends ODataResource {
         segments.add(PathSegmentNames.metadata, $METADATA);
         return new ODataMetadataResource(api, segments);
     }
-    clone() {
-        return new ODataMetadataResource(this.api, this.cloneSegments());
-    }
     //#endregion
-    schema() {
-        return undefined;
-    }
     //#region Requests
     get(options) {
         return super
@@ -6839,27 +6927,14 @@ class ODataMetadataResource extends ODataResource {
 
 class ODataSingletonResource extends ODataResource {
     //#region Factory
-    static factory(api, path, type, segments, options) {
+    static factory(api, { path, schema, query, }) {
+        const segments = new ODataPathSegments();
         const segment = segments.add(PathSegmentNames.singleton, path);
-        if (type !== undefined)
-            segment.type(type);
-        options.keep(QueryOptionNames.format);
-        return new ODataSingletonResource(api, segments, options);
-    }
-    clone() {
-        return new ODataSingletonResource(this.api, this.cloneSegments(), this.cloneQuery());
+        if (schema !== undefined)
+            segment.type(schema.type());
+        return new ODataSingletonResource(api, { segments, query, schema });
     }
     //#endregion
-    schema() {
-        let type = this.type();
-        return type !== undefined
-            ? this.api.findStructuredTypeForType(type)
-            : undefined;
-    }
-    asModel(entity, { annots, reset } = {}) {
-        const Model = this.api.modelForType((annots === null || annots === void 0 ? void 0 : annots.type) || this.type());
-        return new Model(entity, { resource: this, annots, reset });
-    }
     key(value) {
         const singleton = this.clone();
         var key = this.resolveKey(value);
@@ -6875,44 +6950,16 @@ class ODataSingletonResource extends ODataResource {
         return singleton;
     }
     navigationProperty(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
-                    : undefined;
-        }
-        return ODataNavigationPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataNavigationPropertyResource.fromResource(this, path);
     }
     property(path) {
-        let type = this.type();
-        if (type !== undefined) {
-            let parser = this.api.parserForType(type);
-            type =
-                parser instanceof ODataStructuredTypeParser
-                    ? parser.typeFor(path)
-                    : undefined;
-        }
-        return ODataPropertyResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataPropertyResource.fromResource(this, path);
     }
     action(path) {
-        let type;
-        const callable = this.api.findCallableForType(path, this.type());
-        if (callable !== undefined) {
-            path = callable.path();
-            type = callable.type();
-        }
-        return ODataActionResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataActionResource.fromResource(this, path);
     }
     function(path) {
-        let type;
-        const callable = this.api.findCallableForType(path, this.type());
-        if (callable !== undefined) {
-            path = callable.path();
-            type = callable.type();
-        }
-        return ODataFunctionResource.factory(this.api, path, type, this.cloneSegments(), this.cloneQuery());
+        return ODataFunctionResource.fromResource(this, path);
     }
     //#region Requests
     post(attrs, options = {}) {
@@ -7030,7 +7077,6 @@ class ODataInStorageCache extends ODataCache {
     }
 }
 
-const CID = '_cid';
 class ODataModelEvent {
     constructor(name, { model, collection, previous, value, track, options, } = {}) {
         this.bubbling = true;
@@ -7090,7 +7136,7 @@ var ODataModelState;
     ODataModelState[ODataModelState["Changed"] = 2] = "Changed";
     ODataModelState[ODataModelState["Unchanged"] = 3] = "Unchanged";
 })(ODataModelState || (ODataModelState = {}));
-function Model({ cid = CID } = {}) {
+function Model({ cid = CID_FIELD_NAME } = {}) {
     return (constructor) => {
         const Klass = constructor;
         if (!Klass.hasOwnProperty('options'))
@@ -7160,15 +7206,21 @@ class ODataModelField {
         return this.parser.isStructuredType();
     }
     structured() {
-        //TODO: Throw error if not found
-        return this.api.findStructuredTypeForType(this.parser.type);
+        let structuredType = this.api.findStructuredTypeForType(this.parser.type);
+        //Throw error if not found
+        if (!structuredType)
+            throw new Error(`Could not find structured type for ${this.parser.type}`);
+        return structuredType;
     }
     isEnumType() {
         return this.parser.isEnumType();
     }
     enum() {
-        //TODO: Throw error if not found
-        return this.api.findEnumTypeForType(this.parser.type);
+        let enumType = this.api.findEnumTypeForType(this.parser.type);
+        //Throw error if not found
+        if (!enumType)
+            throw new Error(`Could not find enum type for ${this.parser.type}`);
+        return enumType;
     }
     validate(value, { method, navigation = false, } = {}) {
         var _a;
@@ -7194,32 +7246,32 @@ class ODataModelField {
                 (value === null || (value === undefined && method !== 'modify')) && // Is null or undefined without patch?
                 !(computed && method === 'create') // Not (Is Computed field and create) ?
             ) {
-                errors.push(`required`);
+                errors['push'](`required`);
             }
             if (this.maxLength !== undefined &&
                 typeof value === 'string' &&
                 value.length > this.maxLength) {
-                errors.push(`maxlength`);
+                errors['push'](`maxlength`);
             }
             if (this.minLength !== undefined &&
                 typeof value === 'string' &&
                 value.length < this.minLength) {
-                errors.push(`minlength`);
+                errors['push'](`minlength`);
             }
             if (this.min !== undefined &&
                 typeof value === 'number' &&
                 value < this.min) {
-                errors.push(`min`);
+                errors['push'](`min`);
             }
             if (this.max !== undefined &&
                 typeof value === 'number' &&
                 value > this.max) {
-                errors.push(`max`);
+                errors['push'](`max`);
             }
             if (this.pattern !== undefined &&
                 typeof value === 'string' &&
                 !this.pattern.test(value)) {
-                errors.push(`pattern`);
+                errors['push'](`pattern`);
             }
             return !Types.isEmpty(errors) ? errors : undefined;
         }
@@ -7265,10 +7317,9 @@ class ODataModelField {
         return this.api.findStructuredTypeForType(this.parser.type);
     }
     modelCollectionFactory({ parent, value, reset, }) {
-        const schema = this.schemaFactory(parent.schema());
         const annots = this.annotationsFactory(parent.annots());
-        const Model = schema === null || schema === void 0 ? void 0 : schema.model;
-        const Collection = schema === null || schema === void 0 ? void 0 : schema.collection;
+        const Model = this.api.modelForType(this.parser.type);
+        const Collection = this.api.collectionForType(this.parser.type);
         if (Model === undefined || Collection === undefined)
             throw Error(`No model for ${this.name}`);
         return this.parser.collection
@@ -7285,22 +7336,18 @@ class ODataModelField {
     }
 }
 class ODataModelOptions {
-    constructor(options, schema) {
+    constructor({ options, schema, }) {
         this.children = [];
         this.name = schema.name;
         this.base = schema.base;
         this.open = schema.open;
         this.schema = schema;
-        this.cid = options.cid || CID;
-        const schemaFields = this.schema.fields({
-            include_navigation: true,
-            include_parents: true,
-        });
+        this.cid = (options === null || options === void 0 ? void 0 : options.cid) || CID_FIELD_NAME;
         this._fields = Object.entries(options.fields).map(([name, options]) => {
             const { field } = options, opts = __rest(options, ["field"]);
             if (field === undefined || name === undefined)
                 throw new Error('Model Properties need name and field');
-            const parser = schemaFields.find((f) => f.name === field);
+            const parser = this.schema.findFieldByName(field);
             if (parser === undefined)
                 throw new Error(`No parser for ${field} with name = ${name}`);
             return new ODataModelField(this, Object.assign({ name, field, parser }, opts));
@@ -7356,19 +7403,22 @@ class ODataModelOptions {
         ];
     }
     field(name) {
-        //TODO: Throw error if not found
-        return this.fields({
+        let field = this.fields({
             include_parents: true,
             include_navigation: true,
         }).find((modelField) => modelField.name === name || modelField.field === name);
+        //Throw error if not found
+        if (field === undefined)
+            throw new Error(`No field with name ${name}`);
+        return field;
     }
     attach(self, resource) {
-        if (self._resource !== undefined &&
+        if (self._resource !== null &&
             resource.type() !== self._resource.type() &&
             !resource.isSubtypeOf(self._resource))
             throw new Error(`Can't reattach ${resource.type()} to ${self._resource.type()}`);
         const current = self._resource;
-        if (current === undefined || !current.isEqualTo(resource)) {
+        if (current === null || !current.isEqualTo(resource)) {
             self._resource = resource;
             self.events$.emit(new ODataModelEvent('attach', {
                 model: self,
@@ -7424,24 +7474,25 @@ class ODataModelOptions {
             throw new Error(`resource: Can't build resource for ${child}`);
         return resource;
     }
-    collectionResourceFactory({ baseResource, } = {}) {
-        if (this.entitySet !== undefined)
-            return ODataEntitySetResource.factory(this.api, this.entitySet.name, this.type(), new ODataPathSegments(), (baseResource === null || baseResource === void 0 ? void 0 : baseResource.cloneQuery()) || new ODataQueryOptions());
-        if (baseResource === undefined)
-            throw new Error("collectionResourceFactory: Can't build resource");
-        return baseResource.clone();
+    collectionResourceFactory(query) {
+        if (this.entitySet === undefined)
+            return undefined;
+        return ODataEntitySetResource.factory(this.api, {
+            path: this.entitySet.name,
+            schema: this.schema,
+            query,
+        });
     }
-    modelResourceFactory({ baseResource, } = {}) {
-        const resource = this.collectionResourceFactory({ baseResource });
+    modelResourceFactory(query) {
+        const resource = this.collectionResourceFactory(query);
         if (resource instanceof ODataEntitySetResource)
             return resource.entity();
         return resource;
     }
     entityResource(self) {
-        let resource = this.modelResourceFactory({
-            baseResource: self._resource,
-            fromSet: true,
-        });
+        let resource = this.modelResourceFactory(self._resource !== null ? self._resource.cloneQuery() : undefined);
+        if (resource === undefined)
+            throw new Error(`entityResource: Can't build resource for ${self}`);
         const key = self.key({ field_mapping: true });
         if (key !== undefined)
             return resource.key(key);
@@ -7453,8 +7504,9 @@ class ODataModelOptions {
         if (parent !== undefined) {
             self._parent = parent;
         }
-        else if (resource !== undefined) {
-            // Resource
+        // Resource
+        resource = resource || this.modelResourceFactory();
+        if (resource !== undefined) {
             this.attach(self, resource);
         }
         // Annotations
@@ -7765,7 +7817,7 @@ class ODataModelOptions {
                     changes.push(key);
             }
         });
-        if (!self._silent && changes.length > 0) {
+        if ((!self._silent && changes.length > 0) || self._reset) {
             self.events$.emit(new ODataModelEvent(self._reset ? 'reset' : 'update', {
                 model: self,
                 options: { changes },
@@ -7967,6 +8019,7 @@ class ODataModelOptions {
 class ODataCollection {
     constructor(entities = [], { parent, resource, annots, model, reset = false, } = {}) {
         this._parent = null;
+        this._resource = null;
         this._entries = [];
         //Events
         this.events$ = new EventEmitter();
@@ -7981,11 +8034,9 @@ class ODataCollection {
         if (parent !== undefined) {
             this._parent = parent;
         }
-        else {
-            // Resource
-            resource = resource || this._model.meta.collectionResourceFactory();
-            if (resource === undefined)
-                throw new Error(`Can't create collection without resource`);
+        // Resource
+        resource = (resource || this._model.meta.collectionResourceFactory());
+        if (resource !== undefined) {
             this.attach(resource);
         }
         // Annotations
@@ -8011,18 +8062,16 @@ class ODataCollection {
         return ODataModelOptions.resource(this);
     }
     attach(resource) {
-        if (this._resource !== undefined &&
+        if (this._resource !== null &&
             this._resource.type() !== resource.type() &&
             !resource.isSubtypeOf(this._resource))
             throw new Error(`Can't reattach ${resource.type()} to ${this._resource.type()}`);
         this._entries.forEach(({ model }) => {
-            const mr = this._model.meta.modelResourceFactory({
-                baseResource: resource,
-            });
+            const mr = this._model.meta.modelResourceFactory(resource.cloneQuery());
             model.attach(mr);
         });
         const current = this._resource;
-        if (current === undefined || !current.isEqualTo(resource)) {
+        if (current === null || !current.isEqualTo(resource)) {
             this._resource = resource;
             this.events$.emit(new ODataModelEvent('attach', {
                 collection: this,
@@ -8288,11 +8337,17 @@ class ODataCollection {
         }
     }
     removeReference(model, options) {
-        const resource = this.resource();
+        let resource = this.resource();
         if (!model.isNew() && resource instanceof ODataNavigationPropertyResource) {
+            let target = this._model.meta.api.options.deleteRefBy === 'id'
+                ? model._meta.entityResource(model)
+                : undefined;
+            if (this._model.meta.api.options.deleteRefBy === 'path') {
+                resource = resource.key(model.key());
+            }
             return resource
                 .reference()
-                .remove(model._meta.entityResource(model), options)
+                .remove(target, options)
                 .pipe(map(() => model));
         }
         return of(model);
@@ -8472,22 +8527,22 @@ class ODataCollection {
             this._removeModel(m[0], { silent: true, reset });
             this._addModel(m[0], { silent: true, reset, position: m[1], reparent });
         });
-        if (toAdd.length > 0 ||
-            toRemove.length > 0 ||
-            toMerge.length > 0 ||
-            toSort.length > 0) {
+        if ((!silent &&
+            (toAdd.length > 0 ||
+                toRemove.length > 0 ||
+                toMerge.length > 0 ||
+                toSort.length > 0)) ||
+            reset) {
             this._sortBy = null;
-            if (!silent) {
-                this.events$.emit(new ODataModelEvent(reset ? 'reset' : 'update', {
-                    collection: this,
-                    options: {
-                        added: toAdd,
-                        removed: toRemove,
-                        merged: toMerge,
-                        sorted: toSort,
-                    },
-                }));
-            }
+            this.events$.emit(new ODataModelEvent(reset ? 'reset' : 'update', {
+                collection: this,
+                options: {
+                    added: toAdd,
+                    removed: toRemove,
+                    merged: toMerge,
+                    sorted: toSort,
+                },
+            }));
         }
     }
     query(func) {
@@ -8697,6 +8752,7 @@ class ODataModel {
         this._attributes = {};
         this._changes = {};
         this._relations = {};
+        this._resource = null;
         this._reset = false;
         this._reparent = false;
         this._silent = false;
@@ -8715,8 +8771,27 @@ class ODataModel {
         let defaults = this.defaults();
         this.assign(Objects.merge(defaults, attrs), { reset });
     }
-    static buildMeta(options, schema) {
-        this.meta = new ODataModelOptions(options, schema);
+    static buildMeta({ options, schema, }) {
+        if (options === undefined) {
+            let fields = schema
+                .fields({ include_navigation: true, include_parents: true })
+                .reduce((acc, f) => {
+                let name = f.name;
+                // Prevent collision with reserved keywords
+                while (RESERVED_FIELD_NAMES.includes(name)) {
+                    name = name + '_';
+                }
+                return Object.assign(acc, {
+                    [name]: {
+                        field: f.name,
+                        default: f.default,
+                        required: !f.nullable,
+                    },
+                });
+            }, {});
+            options = { fields };
+        }
+        this.meta = new ODataModelOptions({ options, schema });
     }
     //#region Resources
     resource() {
@@ -9118,6 +9193,7 @@ class ODataModel {
         return (_a = this.collection()) === null || _a === void 0 ? void 0 : _a.prev(this);
     }
 }
+const RESERVED_FIELD_NAMES = Object.getOwnPropertyNames(ODataModel.prototype);
 
 /**
  * Api abstraction for consuming OData services.
@@ -9169,19 +9245,19 @@ class ODataApi {
         switch ((_a = segments.last()) === null || _a === void 0 ? void 0 : _a.name) {
             case PathSegmentNames.entitySet:
                 if ((_b = segments.last()) === null || _b === void 0 ? void 0 : _b.hasKey()) {
-                    return new ODataEntityResource(this, segments, query);
+                    return new ODataEntityResource(this, { segments, query });
                 }
                 else {
-                    return new ODataEntitySetResource(this, segments, query);
+                    return new ODataEntitySetResource(this, { segments, query });
                 }
             case PathSegmentNames.navigationProperty:
-                return new ODataNavigationPropertyResource(this, segments, query);
+                return new ODataNavigationPropertyResource(this, { segments, query });
             case PathSegmentNames.singleton:
-                return new ODataSingletonResource(this, segments, query);
+                return new ODataSingletonResource(this, { segments, query });
             case PathSegmentNames.action:
-                return new ODataActionResource(this, segments, query);
+                return new ODataActionResource(this, { segments, query });
             case PathSegmentNames.function:
-                return new ODataFunctionResource(this, segments, query);
+                return new ODataFunctionResource(this, { segments, query });
         }
         throw new Error('No Resource for json');
     }
@@ -9201,51 +9277,45 @@ class ODataApi {
     }
     /**
      * Build a singleton resource.
-     * @param name Name of the singleton
+     * @param path Name of the singleton
      * @returns
      */
-    singleton(name) {
-        var _a;
-        const type = (_a = this.findEntitySetByName(name)) === null || _a === void 0 ? void 0 : _a.entityType;
-        return ODataSingletonResource.factory(this, name, type, new ODataPathSegments(), new ODataQueryOptions());
+    singleton(path) {
+        const entitySet = this.findEntitySetByName(path);
+        const schema = entitySet !== undefined
+            ? this.findStructuredTypeForType(entitySet.entityType)
+            : undefined;
+        return ODataSingletonResource.factory(this, { path, schema });
     }
     /**
      * Build an entity set resource.
-     * @param name Name of the entity set
+     * @param path Name of the entity set
      * @returns
      */
-    entitySet(name) {
-        var _a;
-        const type = (_a = this.findEntitySetByName(name)) === null || _a === void 0 ? void 0 : _a.entityType;
-        return ODataEntitySetResource.factory(this, name, type, new ODataPathSegments(), new ODataQueryOptions());
+    entitySet(path) {
+        const entitySet = this.findEntitySetByName(path);
+        const schema = entitySet !== undefined
+            ? this.findStructuredTypeForType(entitySet.entityType)
+            : undefined;
+        return ODataEntitySetResource.factory(this, { path, schema });
     }
     /**
      * Unbound Action
-     * @param  {string} name?
+     * @param  {string} path?
      * @returns ODataActionResource
      */
-    action(name) {
-        let type;
-        const callable = this.findCallableForType(name);
-        if (callable !== undefined) {
-            name = callable.path();
-            type = callable.type();
-        }
-        return ODataActionResource.factory(this, name, type, new ODataPathSegments(), new ODataQueryOptions());
+    action(path) {
+        const schema = this.findCallableForType(path);
+        return ODataActionResource.factory(this, { path, schema });
     }
     /**
      * Unbound Function
-     * @param  {string} name?
+     * @param  {string} path?
      * @returns ODataFunctionResource
      */
-    function(name) {
-        let type;
-        const callable = this.findCallableForType(name);
-        if (callable !== undefined) {
-            name = callable.path();
-            type = callable.type();
-        }
-        return ODataFunctionResource.factory(this, name, type, new ODataPathSegments(), new ODataQueryOptions());
+    function(path) {
+        const schema = this.findCallableForType(path);
+        return ODataFunctionResource.factory(this, { path, schema });
     }
     request(req) {
         let res$ = this.requester !== undefined ? this.requester(req) : NEVER;
@@ -9301,14 +9371,43 @@ class ODataApi {
         return (_a = this.findStructuredTypeForType(type)) === null || _a === void 0 ? void 0 : _a.model;
     }
     modelForType(type) {
-        return (type && this.findModelForType(type)) || ODataModel;
+        let Model = this.findModelForType(type);
+        if (Model === undefined) {
+            // Build Ad-hoc model
+            let schema = this.findStructuredTypeForType(type);
+            if (schema === undefined)
+                throw Error(`No schema for ${type}`);
+            Model = class extends ODataModel {
+            };
+            // Build Meta
+            Model.buildMeta({ schema });
+            // Configure
+            Model.meta.configure({
+                findOptionsForType: (type) => this.findOptionsForType(type),
+                options: this.options,
+            });
+            // Store New Model for next time
+            schema.model = Model;
+        }
+        return Model;
     }
     findCollectionForType(type) {
         var _a;
         return (_a = this.findStructuredTypeForType(type)) === null || _a === void 0 ? void 0 : _a.collection;
     }
     collectionForType(type) {
-        return (type && this.findCollectionForType(type)) || ODataCollection;
+        let Collection = this.findCollectionForType(type);
+        if (Collection === undefined) {
+            let schema = this.findStructuredTypeForType(type);
+            if (schema === undefined)
+                throw Error('');
+            Collection = class extends ODataCollection {
+            };
+            Collection.model = this.modelForType(type);
+            // Store New Collection for next time
+            schema.collection = Collection;
+        }
+        return Collection;
     }
     findServiceForType(type) {
         var _a;
@@ -9863,9 +9962,9 @@ class ODataClient {
         return this.request('PUT', resource, addBody(options, body));
     }
 }
-ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", 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: "12.2.7", ngImport: i0, type: ODataClient, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataClient, decorators: [{
+ODataClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", 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.1.1", ngImport: i0, type: ODataClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataClient, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -10117,9 +10216,9 @@ class ODataServiceFactory {
         })(this.client, singletonName, apiNameOrEntityType);
     }
 }
-ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
-ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataServiceFactory });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataServiceFactory, decorators: [{
+ODataServiceFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataServiceFactory, deps: [{ token: ODataClient }], target: i0.ɵɵFactoryTarget.Injectable });
+ODataServiceFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataServiceFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataServiceFactory, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: ODataClient }]; } });
 
@@ -10143,10 +10242,10 @@ class ODataModule {
         };
     }
 }
-ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataModule, imports: [HttpClientModule] });
-ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [[HttpClientModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImport: i0, type: ODataModule, decorators: [{
+ODataModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ODataModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, imports: [HttpClientModule] });
+ODataModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, providers: [ODataClient, ODataServiceFactory], imports: [[HttpClientModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ODataModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [HttpClientModule],
@@ -10162,5 +10261,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { BUBBLING, CID, Dates, Durations, EDM_PARSERS, Enums, Http, INCLUDE_DEEP, INCLUDE_SHALLOW, ITEM_ROOT, Model, ModelField, NONE_PARSER, ODATA_CONFIGURATIONS, OData, ODataActionResource, ODataAnnotations, ODataApi, ODataBaseService, ODataBatchRequest, ODataBatchResource, ODataCache, ODataCallable, ODataCallableParser, ODataClient, ODataCollection, ODataCountResource, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityContainer, ODataEntityResource, ODataEntitySet, ODataEntitySetResource, ODataEntitySetService, ODataEntityTypeKey, ODataEnumType, ODataEnumTypeFieldParser, ODataEnumTypeParser, ODataFunctionResource, ODataInMemoryCache, ODataInStorageCache, ODataMediaResource, ODataMetadata, ODataMetadataResource, ODataModel, ODataModelEvent, 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, PathSegmentNames, QueryCustomTypes, QueryOptionNames, SegmentHandler, StandardAggregateMethods, Strings, Types, Urls, alias, binary, buildPathAndQuery, createSettings, duration, isQueryCustomType, normalizeValue, raw };
-//# sourceMappingURL=angular-odata.js.map
+export { BUBBLING, Dates, Durations, EDM_PARSERS, Enums, Http, INCLUDE_DEEP, INCLUDE_SHALLOW, ITEM_ROOT, Model, ModelField, NONE_PARSER, ODATA_CONFIGURATIONS, OData, ODataActionResource, ODataAnnotations, ODataApi, ODataBaseService, ODataBatchRequest, ODataBatchResource, ODataCache, ODataCallable, ODataCallableParser, ODataClient, ODataCollection, ODataCountResource, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityContainer, ODataEntityResource, ODataEntitySet, ODataEntitySetResource, ODataEntitySetService, ODataEntityTypeKey, ODataEnumType, ODataEnumTypeFieldParser, ODataEnumTypeParser, ODataFunctionResource, ODataInMemoryCache, ODataInStorageCache, ODataMediaResource, ODataMetadata, ODataMetadataResource, ODataModel, ODataModelEvent, 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, PathSegmentNames, QueryCustomTypes, QueryOptionNames, RESERVED_FIELD_NAMES, SegmentHandler, StandardAggregateMethods, Strings, Types, Urls, alias, binary, buildPathAndQuery, createSettings, duration, isQueryCustomType, normalizeValue, raw };
+//# sourceMappingURL=angular-odata.mjs.map