angular-odata 0.78.1 → 0.95.0

package/esm2020/lib/resources/types/function.mjs

@@ -0,0 +1,137 @@
+import { map } from 'rxjs/operators';
+import { ODataCallable } from '../../schema/callable';
+import { PathSegmentNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataResource } from '../resource';
+export class ODataFunctionResource extends ODataResource {
+    //#region Factory
+    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 (schema !== undefined)
+            segment.type(schema.type());
+        return new ODataFunctionResource(api, {
+            segments,
+            query,
+            schema,
+        });
+    }
+    static fromResource(resource, path) {
+        const baseType = resource.type();
+        const schema = resource.api.findCallableForType(path, baseType);
+        const bindingType = schema?.binding()?.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() {
+        return this.schema instanceof ODataCallable
+            ? this.schema.parser.return?.type
+            : undefined;
+    }
+    parameters(params, { alias } = {}) {
+        let parameters = params !== null ? this.encode(params) : null;
+        if (alias && parameters !== null) {
+            this.query((q) => {
+                parameters = Object.entries(parameters).reduce((acc, [name, param]) => {
+                    return Object.assign(acc, { [name]: q.alias(param, name) });
+                }, {});
+            });
+        }
+        return this.clone().segment((s) => s.function().parameters(parameters));
+    }
+    //#region Requests
+    get(options) {
+        return super.get(options);
+    }
+    call(params, { alias, ...options } = {}) {
+        return this.parameters(params, { alias }).get(options);
+    }
+    /**
+     * Execute the function with the given parameters and return the result as a property
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callProperty(params, { alias, ...options } = {}) {
+        return this.call(params, {
+            responseType: 'property',
+            alias,
+            ...options,
+        }).pipe(map(({ property }) => property));
+    }
+    /**
+     * Execute the function with the given parameters and return the result as a entity
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callEntity(params, { alias, ...options } = {}) {
+        return this.call(params, {
+            responseType: 'entity',
+            alias,
+            ...options,
+        }).pipe(map(({ entity }) => entity));
+    }
+    /**
+     * Execute the function with the given parameters and return the result as a model
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callModel(params, { alias, ...options } = {}) {
+        return this.call(params, {
+            responseType: 'entity',
+            alias,
+            ...options,
+        }).pipe(map(({ entity, annots }) => entity ? this.asModel(entity, { annots, reset: true }) : null));
+    }
+    /**
+     * Execute the function with the given parameters and return the result as a entities
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callEntities(params, { alias, ...options } = {}) {
+        return this.call(params, {
+            responseType: 'entities',
+            alias,
+            ...options,
+        }).pipe(map(({ entities }) => entities));
+    }
+    /**
+     * Execute the function with the given parameters and return the result as a collection
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callCollection(params, { alias, ...options } = {}) {
+        return this.call(params, {
+            responseType: 'entities',
+            alias,
+            ...options,
+        }).pipe(map(({ entities, annots }) => entities
+            ? this.asCollection(entities, { annots, reset: true })
+            : null));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/types/function.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { ODataApi } from '../../api';\nimport { ODataCollection } from '../../models/collection';\nimport { ODataModel } from '../../models/model';\nimport { ODataCallable } from '../../schema/callable';\nimport { PathSegmentNames } from '../../types';\nimport { ODataPathSegments } from '../path';\nimport { ODataQueryOptions } from '../query';\nimport { ODataResource } from '../resource';\nimport { ODataEntities, ODataEntity, ODataProperty } from '../responses';\nimport {\n  ODataEntitiesOptions,\n  ODataEntityOptions,\n  ODataNoneOptions,\n  ODataOptions,\n  ODataPropertyOptions,\n} from './options';\n\nexport class ODataFunctionResource<P, R> extends ODataResource<R> {\n  //#region Factory\n  static factory<P, R>(\n    api: ODataApi,\n    {\n      path,\n      schema,\n      segments,\n      query,\n    }: {\n      path?: string;\n      schema?: ODataCallable<R>;\n      segments?: ODataPathSegments;\n      query?: ODataQueryOptions<R>;\n    }\n  ) {\n    segments = segments || new ODataPathSegments();\n    path = schema !== undefined ? schema.path() : path;\n    if (path === undefined)\n      throw new Error(`ODataActionResource: path is required`);\n\n    const segment = segments.add(PathSegmentNames.function, path);\n    if (schema !== undefined) segment.type(schema.type());\n    return new ODataFunctionResource<P, R>(api, {\n      segments,\n      query,\n      schema,\n    });\n  }\n\n  static fromResource<P, R>(resource: ODataResource<any>, path: string) {\n    const baseType = resource.type();\n    const schema = resource.api.findCallableForType<R>(path, baseType);\n    const bindingType = schema?.binding()?.type;\n\n    const func = ODataFunctionResource.factory<P, R>(resource.api, {\n      path,\n      schema,\n      segments: resource.cloneSegments(),\n    });\n\n    // Switch entitySet to binding type if available\n    if (bindingType !== undefined && bindingType !== baseType) {\n      let entitySet = resource.api.findEntitySetForType(bindingType);\n      if (entitySet !== undefined) {\n        func.segment((s) => s.entitySet().path(entitySet!.name));\n      }\n    }\n\n    return func;\n  }\n  //#endregion\n\n  override returnType() {\n    return this.schema instanceof ODataCallable\n      ? this.schema.parser.return?.type\n      : undefined;\n  }\n\n  parameters(params: P | null, { alias }: { alias?: boolean } = {}) {\n    let parameters = params !== null ? this.encode(params) : null;\n    if (alias && parameters !== null) {\n      this.query((q) => {\n        parameters = Object.entries(parameters).reduce((acc, [name, param]) => {\n          return Object.assign(acc, { [name]: q.alias(param, name) });\n        }, {});\n      });\n    }\n    return this.clone<ODataFunctionResource<P, R>>().segment((s) =>\n      s.function().parameters<P>(parameters)\n    );\n  }\n\n  //#region Requests\n  protected override get(\n    options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions\n  ): Observable<any> {\n    return super.get(options);\n  }\n  //#endregion\n\n  //#region Shortcuts\n  /**\n   * Execute the function\n   * @param params Parameters to be sent to the function\n   * @param alias If true, the parameters will be send using aliases\n   * @param options Options for the request\n   */\n  call(\n    params: P | null,\n    options?: { alias?: boolean } & ODataEntityOptions\n  ): Observable<ODataEntity<R>>;\n  call(\n    params: P | null,\n    options?: { alias?: boolean } & ODataEntitiesOptions\n  ): Observable<ODataEntities<R>>;\n  call(\n    params: P | null,\n    options?: { alias?: boolean } & ODataPropertyOptions\n  ): Observable<ODataProperty<R>>;\n  call(\n    params: P | null,\n    options?: { alias?: boolean } & ODataNoneOptions\n  ): Observable<null>;\n  call(\n    params: P | null,\n    {\n      alias,\n      ...options\n    }: { alias?: boolean } & ODataEntityOptions &\n      ODataEntitiesOptions &\n      ODataPropertyOptions &\n      ODataNoneOptions = {}\n  ): Observable<any> {\n    return this.parameters(params, { alias }).get(options);\n  }\n\n  /**\n   * Execute the function with the given parameters and return the result as a property\n   * @param params Parameters to be sent to the function\n   * @param alias If true, the parameters will be send using aliases\n   * @param options Options for the request\n   * @returns Observable of the result of the function\n   */\n  callProperty(\n    params: P | null,\n    { alias, ...options }: { alias?: boolean } & ODataOptions = {}\n  ): Observable<R | null> {\n    return this.call(params, {\n      responseType: 'property',\n      alias,\n      ...options,\n    }).pipe(map(({ property }) => property));\n  }\n\n  /**\n   * Execute the function with the given parameters and return the result as a entity\n   * @param params Parameters to be sent to the function\n   * @param alias If true, the parameters will be send using aliases\n   * @param options Options for the request\n   * @returns Observable of the result of the function\n   */\n  callEntity(\n    params: P | null,\n    { alias, ...options }: { alias?: boolean } & ODataOptions = {}\n  ): Observable<R | null> {\n    return this.call(params, {\n      responseType: 'entity',\n      alias,\n      ...options,\n    }).pipe(map(({ entity }) => entity));\n  }\n\n  /**\n   * Execute the function with the given parameters and return the result as a model\n   * @param params Parameters to be sent to the function\n   * @param alias If true, the parameters will be send using aliases\n   * @param options Options for the request\n   * @returns Observable of the result of the function\n   */\n  callModel<M extends ODataModel<R>>(\n    params: P | null,\n    { alias, ...options }: { alias?: boolean } & ODataOptions = {}\n  ): Observable<M | null> {\n    return this.call(params, {\n      responseType: 'entity',\n      alias,\n      ...options,\n    }).pipe(\n      map(({ entity, annots }) =>\n        entity ? this.asModel<M>(entity, { annots, reset: true }) : null\n      )\n    );\n  }\n\n  /**\n   * Execute the function with the given parameters and return the result as a entities\n   * @param params Parameters to be sent to the function\n   * @param alias If true, the parameters will be send using aliases\n   * @param options Options for the request\n   * @returns Observable of the result of the function\n   */\n  callEntities(\n    params: P | null,\n    { alias, ...options }: { alias?: boolean } & ODataOptions = {}\n  ): Observable<R[] | null> {\n    return this.call(params, {\n      responseType: 'entities',\n      alias,\n      ...options,\n    }).pipe(map(({ entities }) => entities));\n  }\n\n  /**\n   * Execute the function with the given parameters and return the result as a collection\n   * @param params Parameters to be sent to the function\n   * @param alias If true, the parameters will be send using aliases\n   * @param options Options for the request\n   * @returns Observable of the result of the function\n   */\n  callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(\n    params: P | null,\n    { alias, ...options }: { alias?: boolean } & ODataOptions = {}\n  ): Observable<C | null> {\n    return this.call(params, {\n      responseType: 'entities',\n      alias,\n      ...options,\n    }).pipe(\n      map(({ entities, annots }) =>\n        entities\n          ? this.asCollection<M, C>(entities, { annots, reset: true })\n          : null\n      )\n    );\n  }\n  //#endregion\n}\n"]}

package/esm2020/lib/resources/types/media.mjs

@@ -0,0 +1,41 @@
+import { $VALUE } from '../../constants';
+import { PathSegmentNames } from '../../types';
+import { Http } from '../../utils';
+import { ODataResource } from '../resource';
+export class ODataMediaResource extends ODataResource {
+    //#region Factory
+    static factory(api, { segments, query, }) {
+        segments.add(PathSegmentNames.value, $VALUE);
+        return new ODataMediaResource(api, { segments, query });
+    }
+    //#endregion
+    //#region Requests
+    get(options) {
+        return super.get(options);
+    }
+    put(data, options = {}) {
+        return super.put(data, options);
+    }
+    fetch(options) {
+        return this.get(options);
+    }
+    fetchArraybuffer(options = {}) {
+        return this.fetch({ responseType: 'arraybuffer', ...options });
+    }
+    fetchBlob(options = {}) {
+        return this.fetch({ responseType: 'blob', ...options });
+    }
+    upload(data, options = {}) {
+        return this.put(data, options);
+    }
+    uploadArrayBuffer(data, contentType, options = {}) {
+        options.headers = Http.mergeHttpHeaders(options.headers || {}, {
+            'Content-Type': contentType,
+        });
+        return this.upload(data, options);
+    }
+    uploadBlob(data, options = {}) {
+        return this.upload(data, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/resources/types/metadata.mjs

@@ -0,0 +1,30 @@
+import { map } from 'rxjs/operators';
+import { $METADATA } from '../../constants';
+import { PathSegmentNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataResource } from '../resource';
+import { ODataMetadata } from '../responses';
+export class ODataMetadataResource extends ODataResource {
+    constructor(api, segments) {
+        super(api, { segments });
+    }
+    //#region Factory
+    static factory(api) {
+        let segments = new ODataPathSegments();
+        segments.add(PathSegmentNames.metadata, $METADATA);
+        return new ODataMetadataResource(api, segments);
+    }
+    //#endregion
+    //#region Requests
+    get(options) {
+        return super
+            .get({ responseType: 'text', ...options })
+            .pipe(map((body) => new ODataMetadata(body)));
+    }
+    //#endregion
+    //#region Shortcuts
+    fetch(options) {
+        return this.get(options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/resources/types/navigation-property.mjs

@@ -0,0 +1,226 @@
+import { EMPTY } from 'rxjs';
+import { concatMap, expand, map, toArray } from 'rxjs/operators';
+import { PathSegmentNames, QueryOptionNames } from '../../types';
+import { ODataResource } from '../resource';
+import { ODataCountResource } from './count';
+import { ODataMediaResource } from './media';
+import { ODataPropertyResource } from './property';
+import { ODataReferenceResource } from './reference';
+/**
+ * OData Navigation Property Resource
+ * https://www.odata.org/getting-started/advanced-tutorial/#containment
+ * https://www.odata.org/getting-started/advanced-tutorial/#derived
+ */
+export class ODataNavigationPropertyResource extends ODataResource {
+    //#region Factory
+    static factory(api, { path, type, schema, segments, query, }) {
+        const segment = segments.add(PathSegmentNames.navigationProperty, path);
+        if (schema !== undefined)
+            segment.type(schema.type());
+        else if (type !== undefined)
+            segment.type(type);
+        query?.keep(QueryOptionNames.format);
+        return new ODataNavigationPropertyResource(api, {
+            segments,
+            query,
+            schema,
+        });
+    }
+    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?.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
+    key(value) {
+        const navigation = this.clone();
+        var key = this.resolveKey(value);
+        if (key !== undefined)
+            navigation.segment((s) => s.navigationProperty().key(key));
+        return navigation;
+    }
+    keys(values) {
+        const navigation = this.clone();
+        const types = this.pathSegments.types({ key: true });
+        const keys = values.map((value, index) => ODataResource.resolveKey(value, this.api.findStructuredTypeForType(types[index])));
+        navigation.segment((s) => s.keys(keys));
+        return navigation;
+    }
+    media() {
+        return ODataMediaResource.factory(this.api, {
+            segments: this.cloneSegments(),
+            query: this.cloneQuery(),
+        });
+    }
+    reference() {
+        return ODataReferenceResource.factory(this.api, {
+            segments: this.cloneSegments(),
+        });
+    }
+    navigationProperty(path) {
+        return ODataNavigationPropertyResource.fromResource(this, path);
+    }
+    property(path) {
+        return ODataPropertyResource.fromResource(this, path);
+    }
+    count() {
+        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 ODataNavigationPropertyResource(this.api, {
+            segments,
+            schema: castSchema,
+            query: this.cloneQuery(),
+        });
+    }
+    //#region Requests
+    post(attrs, options = {}) {
+        return super.post(attrs, { responseType: 'entity', ...options });
+    }
+    put(attrs, options = {}) {
+        return super.put(attrs, { responseType: 'entity', ...options });
+    }
+    patch(attrs, options = {}) {
+        return super.patch(attrs, { responseType: 'entity', ...options });
+    }
+    delete(options = {}) {
+        return super.delete({ responseType: 'entity', ...options });
+    }
+    get(options = {}) {
+        return super.get(options);
+    }
+    //#endregion
+    //#region Shortcuts
+    /**
+     * Create a new entity
+     * @param attrs The entity attributes
+     * @param options Options for the request
+     * @returns The created entity with the annotations
+     */
+    create(attrs, options) {
+        return this.post(attrs, options);
+    }
+    /**
+     * Update an existing entity
+     * @param attrs The entity attributes
+     * @param options Options for the request
+     * @param etag The etag of the entity
+     * @returns The updated entity with the annotations
+     */
+    update(attrs, options) {
+        return this.put(attrs, options);
+    }
+    /**
+     * Modify an existing entity
+     * @param attrs The entity attributes
+     * @param options Options for the request
+     * @param etag The etag of the entity
+     * @returns The modified entity with the annotations
+     */
+    modify(attrs, options) {
+        return this.patch(attrs, options);
+    }
+    /**
+     * Delete an existing entity
+     * @param options Options for the request
+     * @param etag The etag of the entity
+     * @returns An observable of the destroy
+     */
+    destroy(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({ responseType: 'entity', ...options }).pipe(map(({ entity }) => entity));
+    }
+    /**
+     * Fetch the entity and return as model
+     * @param options Options for the request
+     * @returns The model
+     */
+    fetchModel(options = {}) {
+        return this.fetch({ responseType: 'entity', ...options }).pipe(map(({ entity, annots }) => entity ? this.asModel(entity, { annots, reset: true }) : null));
+    }
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options = {}) {
+        return this.fetch({ responseType: 'entities', ...options }).pipe(map(({ entities }) => entities));
+    }
+    /**
+     * Fetch entities and return as collection
+     * @param options Options for the request
+     * @returns The collection
+     */
+    fetchCollection(options = {}) {
+        return this.fetch({ responseType: 'entities', ...options }).pipe(map(({ entities, annots }) => entities
+            ? this.asCollection(entities, { annots, reset: true })
+            : null));
+    }
+    /**
+     * Fetch all entities
+     * @param options Options for the request
+     * @returns All entities
+     */
+    fetchAll(options = {}) {
+        let res = this.clone();
+        // Clean Paging
+        res.query((q) => q.clearPaging());
+        let fetch = (opts) => {
+            if (opts) {
+                res.query((q) => q.paging(opts));
+            }
+            return res.fetch({ responseType: 'entities', ...options });
+        };
+        return fetch().pipe(expand(({ annots: meta }) => meta.skip || meta.skiptoken ? fetch(meta) : EMPTY), concatMap(({ entities }) => entities || []), toArray());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navigation-property.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/types/navigation-property.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAc,MAAM,MAAM,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAIjE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAErD;;;;GAIG;AACH,MAAM,OAAO,+BAAmC,SAAQ,aAAgB;IACtE,iBAAiB;IACjB,MAAM,CAAC,OAAO,CACZ,GAAa,EACb,EACE,IAAI,EACJ,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,KAAK,GAON;QAED,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;QACxE,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;aACjD,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChD,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,IAAI,+BAA+B,CAAI,GAAG,EAAE;YACjD,QAAQ;YACR,KAAK;YACL,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAED,MAAM,CAAC,YAAY,CAAI,QAA4B,EAAE,IAAY;QAC/D,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,UAAU,GAAG,QAAQ,CAAC,MAA8C,CAAC;QACzE,IAAI,SAA6B,CAAC;QAClC,IAAI,WAA+C,CAAC;QACpD,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5B,MAAM,KAAK,GAAG,UAAU,CAAC,eAAe,CAAI,IAAI,CAAC,CAAC;YAClD,SAAS,GAAG,KAAK,EAAE,IAAI,CAAC;YACxB,WAAW;gBACT,SAAS,KAAK,SAAS;oBACrB,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,yBAAyB,CAAC,SAAS,CAAC;oBACnD,CAAC,CAAC,SAAS,CAAC;YAChB,UAAU;gBACR,KAAK,KAAK,SAAS;oBACjB,CAAC,CAAC,UAAU,CAAC,kBAAkB,CAAI,KAAK,CAAC;oBACzC,CAAC,CAAC,SAAS,CAAC;SACjB;QAED,MAAM,UAAU,GAAG,+BAA+B,CAAC,OAAO,CACxD,QAAQ,CAAC,GAAG,EACZ;YACE,IAAI;YACJ,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,WAAW;YACnB,QAAQ,EAAE,QAAQ,CAAC,aAAa,EAAE;YAClC,KAAK,EAAE,QAAQ,CAAC,UAAU,EAAK;SAChC,CACF,CAAC;QAEF,gDAAgD;QAChD,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,CAAC,IAAI,EAAE,KAAK,QAAQ,EAAE;YAC9D,IAAI,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,oBAAoB,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;YACrE,IAAI,SAAS,KAAK,SAAS,EAAE;gBAC3B,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,SAAU,CAAC,IAAI,CAAC,CAAC,CAAC;aAChE;SACF;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IACD,YAAY;IAEZ,GAAG,CAAC,KAAU;QACZ,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,EAAsC,CAAC;QACpE,IAAI,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,GAAG,KAAK,SAAS;YACnB,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC7D,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,IAAI,CAAC,MAAa;QAChB,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,EAAsC,CAAC;QACpE,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACvC,aAAa,CAAC,UAAU,CACtB,KAAK,EACL,IAAI,CAAC,GAAG,CAAC,yBAAyB,CAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CACpD,CACF,CAAC;QACF,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,KAAK;QACH,OAAO,kBAAkB,CAAC,OAAO,CAAI,IAAI,CAAC,GAAG,EAAE;YAC7C,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE;YAC9B,KAAK,EAAE,IAAI,CAAC,UAAU,EAAK;SAC5B,CAAC,CAAC;IACL,CAAC;IAED,SAAS;QACP,OAAO,sBAAsB,CAAC,OAAO,CAAI,IAAI,CAAC,GAAG,EAAE;YACjD,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE;SAC/B,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB,CAAI,IAAY;QAChC,OAAO,+BAA+B,CAAC,YAAY,CAAI,IAAI,EAAE,IAAI,CAAC,CAAC;IACrE,CAAC;IAED,QAAQ,CAAI,IAAY;QACtB,OAAO,qBAAqB,CAAC,YAAY,CAAI,IAAI,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED,KAAK;QACH,OAAO,kBAAkB,CAAC,OAAO,CAAI,IAAI,CAAC,GAAG,EAAE;YAC7C,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE;YAC9B,KAAK,EAAE,IAAI,CAAC,UAAU,EAAK;SAC5B,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAI,IAAY;QAClB,MAAM,UAAU,GAAG,IAAI,CAAC,MAAgC,CAAC;QACzD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,yBAAyB,CAAI,IAAI,CAAC,CAAC;QAC/D,IACE,UAAU,KAAK,SAAS;YACxB,UAAU,KAAK,SAAS;YACxB,CAAC,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC;YAEnC,MAAM,IAAI,KAAK,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACtC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrD,OAAO,IAAI,+BAA+B,CAAI,IAAI,CAAC,GAAG,EAAE;YACtD,QAAQ;YACR,MAAM,EAAE,UAAU;YAClB,KAAK,EAAE,IAAI,CAAC,UAAU,EAAK;SAC5B,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB;IACC,IAAI,CACrB,KAAiB,EACjB,UAAwB,EAAE;QAE1B,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACnE,CAAC;IAEkB,GAAG,CACpB,KAAiB,EACjB,UAA4C,EAAE;QAE9C,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAClE,CAAC;IAEkB,KAAK,CACtB,KAAiB,EACjB,UAA4C,EAAE;QAE9C,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACpE,CAAC;IAEkB,MAAM,CACvB,UAA4C,EAAE;QAE9C,OAAO,KAAK,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC9D,CAAC;IAEkB,GAAG,CACpB,UAIM,EAAE;QAER,OAAO,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IAED,YAAY;IAEZ,mBAAmB;IACnB;;;;;OAKG;IACH,MAAM,CACJ,KAAiB,EACjB,OAAsB;QAEtB,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CACJ,KAAiB,EACjB,OAA0C;QAE1C,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CACJ,KAAiB,EACjB,OAA0C;QAE1C,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACpC,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,OAA0C;QAChD,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAmBD,KAAK,CACH,UAIM,EAAE;QAER,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,WAAW,CACT,UAGI,EAAE;QAEN,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAC5D,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,CAC5B,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,UAAU,CACR,UAGI,EAAE;QAEN,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAC5D,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,CACzB,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAI,MAAM,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CACjE,CACF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,aAAa,CACX,UAEI,EAAE;QAEN,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAC9D,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,CAChC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,eAAe,CACb,UAGI,EAAE;QAEN,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAC9D,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,CAC3B,QAAQ;YACN,CAAC,CAAC,IAAI,CAAC,YAAY,CAAO,QAAQ,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;YAC5D,CAAC,CAAC,IAAI,CACT,CACF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,QAAQ,CACN,UAEI,EAAE;QAEN,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,EAAsC,CAAC;QAC3D,eAAe;QACf,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QAClC,IAAI,KAAK,GAAG,CAAC,IAIZ,EAAgC,EAAE;YACjC,IAAI,IAAI,EAAE;gBACR,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;aAClC;YACD,OAAO,GAAG,CAAC,KAAK,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QAC7D,CAAC,CAAC;QACF,OAAO,KAAK,EAAE,CAAC,IAAI,CACjB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,CAC1B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAClD,EACD,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ,IAAI,EAAE,CAAC,EAC3C,OAAO,EAAE,CACV,CAAC;IACJ,CAAC;CAEF","sourcesContent":["import { EMPTY, Observable } from 'rxjs';\nimport { concatMap, expand, map, toArray } from 'rxjs/operators';\nimport { ODataApi } from '../../api';\nimport { ODataCollection, ODataModel } from '../../models';\nimport { ODataStructuredType } from '../../schema';\nimport { PathSegmentNames, QueryOptionNames } from '../../types';\nimport { ODataPathSegments } from '../path';\nimport { ODataQueryOptions } from '../query';\nimport { ODataResource } from '../resource';\nimport { ODataEntities, ODataEntity } from '../responses';\nimport { ODataCountResource } from './count';\nimport { ODataMediaResource } from './media';\nimport {\n  ODataEntitiesOptions,\n  ODataEntityOptions,\n  ODataOptions,\n} from './options';\nimport { ODataPropertyResource } from './property';\nimport { ODataReferenceResource } from './reference';\n\n/**\n * OData Navigation Property Resource\n * https://www.odata.org/getting-started/advanced-tutorial/#containment\n * https://www.odata.org/getting-started/advanced-tutorial/#derived\n */\nexport class ODataNavigationPropertyResource<T> extends ODataResource<T> {\n  //#region Factory\n  static factory<N>(\n    api: ODataApi,\n    {\n      path,\n      type,\n      schema,\n      segments,\n      query,\n    }: {\n      path: string;\n      type?: string;\n      schema?: ODataStructuredType<N>;\n      segments: ODataPathSegments;\n      query?: ODataQueryOptions<N>;\n    }\n  ) {\n    const segment = segments.add(PathSegmentNames.navigationProperty, path);\n    if (schema !== undefined) segment.type(schema.type());\n    else if (type !== undefined) segment.type(type);\n    query?.keep(QueryOptionNames.format);\n    return new ODataNavigationPropertyResource<N>(api, {\n      segments,\n      query,\n      schema,\n    });\n  }\n\n  static fromResource<N>(resource: ODataResource<any>, path: string) {\n    const baseType = resource.type();\n    let baseSchema = resource.schema as ODataStructuredType<any> | undefined;\n    let fieldType: string | undefined;\n    let fieldSchema: ODataStructuredType<N> | undefined;\n    if (baseSchema !== undefined) {\n      const field = baseSchema.findFieldByName<N>(path);\n      fieldType = field?.type;\n      fieldSchema =\n        fieldType !== undefined\n          ? resource.api.findStructuredTypeForType(fieldType)\n          : undefined;\n      baseSchema =\n        field !== undefined\n          ? baseSchema.findSchemaForField<N>(field)\n          : undefined;\n    }\n\n    const navigation = ODataNavigationPropertyResource.factory<N>(\n      resource.api,\n      {\n        path,\n        type: fieldType,\n        schema: fieldSchema,\n        segments: resource.cloneSegments(),\n        query: resource.cloneQuery<N>(),\n      }\n    );\n\n    // Switch entitySet to binding type if available\n    if (baseSchema !== undefined && baseSchema.type() !== baseType) {\n      let entitySet = resource.api.findEntitySetForType(baseSchema.type());\n      if (entitySet !== undefined) {\n        navigation.segment((s) => s.entitySet().path(entitySet!.name));\n      }\n    }\n\n    return navigation;\n  }\n  //#endregion\n\n  key(value: any) {\n    const navigation = this.clone<ODataNavigationPropertyResource<T>>();\n    var key = this.resolveKey(value);\n    if (key !== undefined)\n      navigation.segment((s) => s.navigationProperty().key(key));\n    return navigation;\n  }\n\n  keys(values: any[]) {\n    const navigation = this.clone<ODataNavigationPropertyResource<T>>();\n    const types = this.pathSegments.types({ key: true });\n    const keys = values.map((value, index) =>\n      ODataResource.resolveKey(\n        value,\n        this.api.findStructuredTypeForType<T>(types[index])\n      )\n    );\n    navigation.segment((s) => s.keys(keys));\n    return navigation;\n  }\n\n  media() {\n    return ODataMediaResource.factory<T>(this.api, {\n      segments: this.cloneSegments(),\n      query: this.cloneQuery<T>(),\n    });\n  }\n\n  reference() {\n    return ODataReferenceResource.factory<T>(this.api, {\n      segments: this.cloneSegments(),\n    });\n  }\n\n  navigationProperty<N>(path: string) {\n    return ODataNavigationPropertyResource.fromResource<N>(this, path);\n  }\n\n  property<P>(path: string) {\n    return ODataPropertyResource.fromResource<P>(this, path);\n  }\n\n  count() {\n    return ODataCountResource.factory<T>(this.api, {\n      segments: this.cloneSegments(),\n      query: this.cloneQuery<T>(),\n    });\n  }\n\n  cast<C>(type: string) {\n    const baseSchema = this.schema as ODataStructuredType<T>;\n    const castSchema = this.api.findStructuredTypeForType<C>(type);\n    if (\n      castSchema !== undefined &&\n      baseSchema !== undefined &&\n      !castSchema.isSubtypeOf(baseSchema)\n    )\n      throw new Error(`Cannot cast to ${type}`);\n    const segments = this.cloneSegments();\n    segments.add(PathSegmentNames.type, type).type(type);\n    return new ODataNavigationPropertyResource<C>(this.api, {\n      segments,\n      schema: castSchema,\n      query: this.cloneQuery<C>(),\n    });\n  }\n\n  //#region Requests\n  protected override post(\n    attrs: Partial<T>,\n    options: ODataOptions = {}\n  ): Observable<ODataEntity<T>> {\n    return super.post(attrs, { responseType: 'entity', ...options });\n  }\n\n  protected override put(\n    attrs: Partial<T>,\n    options: ODataOptions & { etag?: string } = {}\n  ): Observable<ODataEntity<T>> {\n    return super.put(attrs, { responseType: 'entity', ...options });\n  }\n\n  protected override patch(\n    attrs: Partial<T>,\n    options: ODataOptions & { etag?: string } = {}\n  ): Observable<ODataEntity<T>> {\n    return super.patch(attrs, { responseType: 'entity', ...options });\n  }\n\n  protected override delete(\n    options: ODataOptions & { etag?: string } = {}\n  ): Observable<any> {\n    return super.delete({ responseType: 'entity', ...options });\n  }\n\n  protected override get(\n    options: ODataEntityOptions &\n      ODataEntitiesOptions & {\n        etag?: string;\n        bodyQueryOptions?: QueryOptionNames[];\n      } = {}\n  ): Observable<any> {\n    return super.get(options);\n  }\n\n  //#endregion\n\n  //#region Shortcuts\n  /**\n   * Create a new entity\n   * @param attrs The entity attributes\n   * @param options Options for the request\n   * @returns The created entity with the annotations\n   */\n  create(\n    attrs: Partial<T>,\n    options?: ODataOptions\n  ): Observable<ODataEntity<T>> {\n    return this.post(attrs, options);\n  }\n\n  /**\n   * Update an existing entity\n   * @param attrs The entity attributes\n   * @param options Options for the request\n   * @param etag The etag of the entity\n   * @returns The updated entity with the annotations\n   */\n  update(\n    attrs: Partial<T>,\n    options?: ODataOptions & { etag?: string }\n  ): Observable<ODataEntity<T>> {\n    return this.put(attrs, options);\n  }\n\n  /**\n   * Modify an existing entity\n   * @param attrs The entity attributes\n   * @param options Options for the request\n   * @param etag The etag of the entity\n   * @returns The modified entity with the annotations\n   */\n  modify(\n    attrs: Partial<T>,\n    options?: ODataOptions & { etag?: string }\n  ): Observable<ODataEntity<T>> {\n    return this.patch(attrs, options);\n  }\n\n  /**\n   * Delete an existing entity\n   * @param options Options for the request\n   * @param etag The etag of the entity\n   * @returns An observable of the destroy\n   */\n  destroy(options?: ODataOptions & { etag?: string }): Observable<any> {\n    return this.delete(options);\n  }\n\n  /**\n   * Fetch entity / entities\n   * @param options Options for the request\n   * @return An observable of the entity or entities with annotations\n   */\n  fetch(\n    options?: ODataEntityOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    }\n  ): Observable<ODataEntity<T>>;\n  fetch(\n    options?: ODataEntitiesOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    }\n  ): Observable<ODataEntities<T>>;\n  fetch(\n    options: ODataEntityOptions &\n      ODataEntitiesOptions & {\n        etag?: string;\n        bodyQueryOptions?: QueryOptionNames[];\n      } = {}\n  ): Observable<any> {\n    return this.get(options);\n  }\n\n  /**\n   * Fetch the entity\n   * @param options Options for the request\n   * @returns The entity\n   */\n  fetchEntity(\n    options: ODataOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    } = {}\n  ): Observable<T | null> {\n    return this.fetch({ responseType: 'entity', ...options }).pipe(\n      map(({ entity }) => entity)\n    );\n  }\n\n  /**\n   * Fetch the entity and return as model\n   * @param options Options for the request\n   * @returns The model\n   */\n  fetchModel<M extends ODataModel<T>>(\n    options: ODataOptions & {\n      etag?: string;\n      bodyQueryOptions?: QueryOptionNames[];\n    } = {}\n  ): Observable<M | null> {\n    return this.fetch({ responseType: 'entity', ...options }).pipe(\n      map(({ entity, annots }) =>\n        entity ? this.asModel<M>(entity, { annots, reset: true }) : null\n      )\n    );\n  }\n\n  /**\n   * Fetch entities\n   * @param options Options for the request\n   * @returns The entities\n   */\n  fetchEntities(\n    options: ODataOptions & {\n      bodyQueryOptions?: QueryOptionNames[];\n    } = {}\n  ): Observable<T[] | null> {\n    return this.fetch({ responseType: 'entities', ...options }).pipe(\n      map(({ entities }) => entities)\n    );\n  }\n\n  /**\n   * Fetch entities and return as collection\n   * @param options Options for the request\n   * @returns The collection\n   */\n  fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(\n    options: ODataOptions & {\n      withCount?: boolean;\n      bodyQueryOptions?: QueryOptionNames[];\n    } = {}\n  ): Observable<C | null> {\n    return this.fetch({ responseType: 'entities', ...options }).pipe(\n      map(({ entities, annots }) =>\n        entities\n          ? this.asCollection<M, C>(entities, { annots, reset: true })\n          : null\n      )\n    );\n  }\n\n  /**\n   * Fetch all entities\n   * @param options Options for the request\n   * @returns All entities\n   */\n  fetchAll(\n    options: ODataOptions & {\n      bodyQueryOptions?: QueryOptionNames[];\n    } = {}\n  ): Observable<T[]> {\n    let res = this.clone<ODataNavigationPropertyResource<T>>();\n    // Clean Paging\n    res.query((q) => q.clearPaging());\n    let fetch = (opts?: {\n      skip?: number;\n      skiptoken?: string;\n      top?: number;\n    }): Observable<ODataEntities<T>> => {\n      if (opts) {\n        res.query((q) => q.paging(opts));\n      }\n      return res.fetch({ responseType: 'entities', ...options });\n    };\n    return fetch().pipe(\n      expand(({ annots: meta }) =>\n        meta.skip || meta.skiptoken ? fetch(meta) : EMPTY\n      ),\n      concatMap(({ entities }) => entities || []),\n      toArray()\n    );\n  }\n  //#endregion\n}\n"]}

package/esm2020/lib/resources/types/options.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2xpYi9yZXNvdXJjZXMvdHlwZXMvb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cEhlYWRlcnMsIEh0dHBQYXJhbXMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBGZXRjaFBvbGljeSB9IGZyb20gJy4uLy4uL3R5cGVzJztcbmltcG9ydCB7IE9EYXRhUXVlcnlBcmd1bWVudHMgfSBmcm9tICcuLi9xdWVyeSc7XG5cbmV4cG9ydCB0eXBlIE9EYXRhT3B0aW9ucyA9IHtcbiAgaGVhZGVycz86IEh0dHBIZWFkZXJzIHwgeyBbaGVhZGVyOiBzdHJpbmddOiBzdHJpbmcgfCBzdHJpbmdbXSB9O1xuICBwYXJhbXM/OiBIdHRwUGFyYW1zIHwgeyBbcGFyYW06IHN0cmluZ106IHN0cmluZyB8IHN0cmluZ1tdIH07XG4gIHJlcG9ydFByb2dyZXNzPzogYm9vbGVhbjtcbiAgd2l0aENyZWRlbnRpYWxzPzogYm9vbGVhbjtcbiAgZmV0Y2hQb2xpY3k/OiBGZXRjaFBvbGljeTtcbn07XG5cbmV4cG9ydCB0eXBlIE9EYXRhRW50aXR5T3B0aW9ucyA9IE9EYXRhT3B0aW9ucyAmIHsgcmVzcG9uc2VUeXBlPzogJ2VudGl0eScgfTtcbmV4cG9ydCB0eXBlIE9EYXRhRW50aXRpZXNPcHRpb25zID0gT0RhdGFPcHRpb25zICYge1xuICByZXNwb25zZVR5cGU/OiAnZW50aXRpZXMnO1xuICB3aXRoQ291bnQ/OiBib29sZWFuO1xufTtcbmV4cG9ydCB0eXBlIE9EYXRhUHJvcGVydHlPcHRpb25zID0gT0RhdGFPcHRpb25zICYgeyByZXNwb25zZVR5cGU/OiAncHJvcGVydHknIH07XG5leHBvcnQgdHlwZSBPRGF0YU5vbmVPcHRpb25zID0gT0RhdGFPcHRpb25zICYgeyByZXNwb25zZVR5cGU/OiAnbm9uZScgfTtcbmV4cG9ydCB0eXBlIE9EYXRhUXVlcnlBcmd1bWVudHNPcHRpb25zPFQ+ID0gT0RhdGFRdWVyeUFyZ3VtZW50czxUPiAmIHtcbiAgYWxpYXM/OiBib29sZWFuO1xufSAmIE9EYXRhT3B0aW9ucztcbiJdfQ==