angular-odata 0.130.0 → 0.131.0

package/lib/api.d.ts

@@ -1,11 +1,10 @@
 import { Observable } from 'rxjs';
-import { ODataCache } from './cache';
 import { ModelOptions, ODataCollection, ODataModel, ODataModelOptions } from './models';
 import { ODataApiOptions } from './options';
 import { ODataOptions, ODataResource, ODataSegment } from './resources';
 import { ODataRequest, ODataBatchResource, ODataMetadataResource, ODataActionResource, ODataFunctionResource, ODataEntityResource, ODataEntitySetResource, ODataSingletonResource, ODataNavigationPropertyResource } from './resources';
 import { ODataCallable, ODataEntitySet, ODataEnumType, ODataSchema, ODataSingleton, ODataStructuredType } from './schema';
-import { ApiConfig, EdmType, ODataVersion, Parser, QueryOption, SchemaConfig } from './types';
+import { ODataApiConfig, EdmType, ODataVersion, Parser, QueryOption, ODataSchemaConfig, ODataCache } from './types';
 import { ODataMetadata } from './metadata/metadata';
 /**
  * Api abstraction for consuming OData services.
@@ -19,11 +18,11 @@ export declare class ODataApi {
     default: boolean;
     creation: Date;
     options: ODataApiOptions;
-    cache: ODataCache;
+    cache?: ODataCache;
     errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
     parsers: Map<string, Parser<any>>;
     schemas: ODataSchema[];
-    constructor(config: ApiConfig);
+    constructor(config: ODataApiConfig);
     configure(settings?: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;
@@ -74,9 +73,9 @@ export declare class ODataApi {
      * @returns ODataFunctionResource
      */
     function<P, R>(path: string): ODataFunctionResource<P, R>;
-    callable<T>(type: string): ODataCallable<T> | undefined;
-    enumType<T>(type: string): ODataEnumType<T> | undefined;
-    structuredType<T>(type: string): ODataStructuredType<T> | undefined;
+    callable<T>(type: string): ODataCallable<any> | undefined;
+    enumType<T>(type: string): ODataEnumType<any> | undefined;
+    structuredType<T>(type: string): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
     request<T>(method: string, resource: ODataResource<any>, options: ODataOptions & {
         body?: any;
         etag?: string;
@@ -86,11 +85,11 @@ export declare class ODataApi {
         bodyQueryOptions?: QueryOption[];
     }): Observable<any>;
     private memo;
-    createSchema(config: SchemaConfig): ODataSchema;
+    createSchema(config: ODataSchemaConfig): ODataSchema;
     findSchema(type: string): ODataSchema | undefined;
-    findEnumType<T>(value: string): ODataEnumType<T> | undefined;
-    findStructuredType<T>(value: string): ODataStructuredType<T> | undefined;
-    findCallable<R>(value: string, bindingType?: string): ODataCallable<R> | undefined;
+    findEnumType<T>(value: string): ODataEnumType<any> | undefined;
+    findStructuredType<T>(value: string): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
+    findCallable<R>(value: string, bindingType?: string): ODataCallable<any> | undefined;
     findEntitySet(value: string): ODataEntitySet | undefined;
     findSingleton(value: string): ODataSingleton | undefined;
     findModel(type: string): typeof ODataModel | undefined;

package/lib/cache/cache.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { ODataRequest, ODataResponse } from '../resources';
-import { Cache } from '../types';
+import { ODataCache } from '../types';
 /**
  * A cache entry that holds a payload, a last read time, and a timeout for the entry.
  * @param payload The payload to cache.
@@ -14,7 +14,7 @@ export interface ODataCacheEntry<T> {
     timeout: number;
     tags: string[];
 }
-export declare abstract class ODataCache implements Cache {
+export declare abstract class ODataBaseCache implements ODataCache {
     timeout: number;
     entries: Map<string, ODataCacheEntry<any>>;
     constructor({ timeout }: {

package/lib/cache/memory.d.ts

@@ -1,6 +1,6 @@
 import { ODataRequest, ODataResponse } from '../resources';
-import { ODataCache } from './cache';
-export declare class ODataInMemoryCache extends ODataCache {
+import { ODataBaseCache } from './cache';
+export declare class ODataInMemoryCache extends ODataBaseCache {
     constructor({ timeout }?: {
         timeout?: number;
     });

package/lib/cache/storage.d.ts

@@ -1,6 +1,6 @@
 import { ODataRequest, ODataResponse } from '../resources';
-import { ODataCache } from './cache';
-export declare class ODataInStorageCache extends ODataCache {
+import { ODataBaseCache } from './cache';
+export declare class ODataInStorageCache extends ODataBaseCache {
     name: string;
     storage: Storage;
     constructor({ name, storage, timeout, }: {

package/lib/loaders.d.ts

@@ -1,21 +1,21 @@
 import { Observable } from 'rxjs';
-import { ApiConfig } from './types';
+import { ODataApiConfig } from './types';
 export declare abstract class ODataConfigLoader {
-    abstract loadConfigs(): Observable<ApiConfig[]>;
+    abstract loadConfigs(): Observable<ODataApiConfig[]>;
 }
 export declare class ODataConfigSyncLoader implements ODataConfigLoader {
     private readonly passedConfigs;
-    constructor(passedConfigs: ApiConfig | ApiConfig[]);
-    loadConfigs(): Observable<ApiConfig[]>;
+    constructor(passedConfigs: ODataApiConfig | ODataApiConfig[]);
+    loadConfigs(): Observable<ODataApiConfig[]>;
 }
 export declare class ODataConfigAsyncLoader implements ODataConfigLoader {
     private readonly configs$;
-    constructor(configs$: Observable<ApiConfig>[] | Observable<ApiConfig | ApiConfig[]>);
-    loadConfigs(): Observable<ApiConfig[]>;
+    constructor(configs$: Observable<ODataApiConfig>[] | Observable<ODataApiConfig | ODataApiConfig[]>);
+    loadConfigs(): Observable<ODataApiConfig[]>;
 }
 export declare class ODataMetadataLoader implements ODataConfigLoader {
     private readonly sources$;
     private readonly baseConfigs;
-    constructor(sources$: Observable<string | string[]>, baseConfigs: ApiConfig | ApiConfig[]);
-    loadConfigs(): Observable<ApiConfig[]>;
+    constructor(sources$: Observable<string | string[]>, baseConfigs: ODataApiConfig | ODataApiConfig[]);
+    loadConfigs(): Observable<ODataApiConfig[]>;
 }

package/lib/metadata/csdl/csdl-annotation.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationConfig } from '../../types';
+import { ODataAnnotationConfig } from '../../types';
 import type { CsdlSchema } from './csdl-schema';
 export declare class CsdlAnnotable {
     Annotation?: CsdlAnnotation[];
@@ -24,7 +24,7 @@ export declare class CsdlAnnotations extends CsdlAnnotable {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(): AnnotationConfig[];
+    toConfig(): ODataAnnotationConfig[];
 }
 export declare class CsdlAnnotation {
     Term: string;
@@ -46,7 +46,7 @@ export declare class CsdlAnnotation {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(): AnnotationConfig;
+    toConfig(): ODataAnnotationConfig;
 }
 export declare class CsdlTerm {
     private schema;

package/lib/metadata/csdl/csdl-entity-container.d.ts

@@ -3,7 +3,7 @@ import { CsdlSingleton } from './csdl-singleton';
 import { CsdlFunctionImport, CsdlActionImport } from './csdl-function-action';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlSchema } from './csdl-schema';
-import { EntityContainerConfig } from '../../types';
+import { ODataEntityContainerConfig } from '../../types';
 export declare class CsdlEntityContainer extends CsdlAnnotable {
     private schema;
     Name: string;
@@ -27,5 +27,5 @@ export declare class CsdlEntityContainer extends CsdlAnnotable {
     name(): string;
     namespace(): string;
     fullName(): string;
-    toConfig(base?: Partial<EntityContainerConfig>): EntityContainerConfig;
+    toConfig(base?: Partial<ODataEntityContainerConfig>): ODataEntityContainerConfig;
 }

package/lib/metadata/csdl/csdl-entity-set.d.ts

@@ -1,4 +1,4 @@
-import { EntitySetConfig } from '../../types';
+import { ODataEntitySetConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlEntityContainer } from './csdl-entity-container';
 import { CsdlNavigationPropertyBinding } from './csdl-navigation-property-binding';
@@ -21,5 +21,5 @@ export declare class CsdlEntitySet extends CsdlAnnotable {
     name(): string;
     namespace(): string;
     fullName(): string;
-    toConfig(): EntitySetConfig;
+    toConfig(): ODataEntitySetConfig;
 }

package/lib/metadata/csdl/csdl-enum-type.d.ts

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, EnumTypeFieldConfig } from '../../types';
+import { ODataEnumTypeConfig, ODataEnumTypeFieldConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlSchema } from './csdl-schema';
 export declare class CsdlEnumType extends CsdlAnnotable {
@@ -20,7 +20,7 @@ export declare class CsdlEnumType extends CsdlAnnotable {
     name(): string;
     namespace(): string;
     fullName(): string;
-    toConfig(base?: Partial<EnumTypeConfig>): EnumTypeConfig;
+    toConfig(base?: Partial<ODataEnumTypeConfig>): ODataEnumTypeConfig;
 }
 export declare class CsdlMember extends CsdlAnnotable {
     Name: string;
@@ -33,5 +33,5 @@ export declare class CsdlMember extends CsdlAnnotable {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(base?: Partial<EnumTypeFieldConfig>): EnumTypeFieldConfig;
+    toConfig(base?: Partial<ODataEnumTypeFieldConfig>): ODataEnumTypeFieldConfig;
 }

package/lib/metadata/csdl/csdl-function-action.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, ParameterConfig } from '../../types';
+import { ODataCallableConfig, ODataParameterConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlEntityContainer } from './csdl-entity-container';
 import type { CsdlSchema } from './csdl-schema';
@@ -37,7 +37,7 @@ export declare class CsdlFunction extends CsdlCallable {
     toJson(): {
         IsComposable: boolean | undefined;
     };
-    toConfig(base?: Partial<CallableConfig>): CallableConfig;
+    toConfig(base?: Partial<ODataCallableConfig>): ODataCallableConfig;
 }
 export declare class CsdlAction extends CsdlCallable {
     constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
@@ -50,7 +50,7 @@ export declare class CsdlAction extends CsdlCallable {
     toJson(): {
         [x: string]: any;
     };
-    toConfig(base?: Partial<CallableConfig>): CallableConfig;
+    toConfig(base?: Partial<ODataCallableConfig>): ODataCallableConfig;
 }
 export declare class CsdlFunctionImport {
     private container;
@@ -115,7 +115,7 @@ export declare class CsdlParameter extends CsdlAnnotable {
         Scale: number | undefined;
         SRID: string | undefined;
     };
-    toConfig(): ParameterConfig;
+    toConfig(): ODataParameterConfig;
 }
 export declare class CsdlReturnType {
     Type: string;

package/lib/metadata/csdl/csdl-reference.d.ts

@@ -1,4 +1,4 @@
-import { ReferenceConfig } from '../../types';
+import { ODataReferenceConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 export declare class CsdlReference extends CsdlAnnotable {
     Uri: string;
@@ -13,7 +13,7 @@ export declare class CsdlReference extends CsdlAnnotable {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(base?: Partial<ReferenceConfig>): ReferenceConfig;
+    toConfig(base?: Partial<ODataReferenceConfig>): ODataReferenceConfig;
 }
 export declare class CsdlInclude {
     Namespace: string;

package/lib/metadata/csdl/csdl-schema.d.ts

@@ -4,7 +4,7 @@ import { CsdlEnumType } from './csdl-enum-type';
 import { CsdlEntityType, CsdlComplexType } from './csdl-structured-type';
 import { CsdlFunction, CsdlAction } from './csdl-function-action';
 import { CsdlEntityContainer } from './csdl-entity-container';
-import { SchemaConfig } from '../../types';
+import { ODataSchemaConfig } from '../../types';
 export declare class CsdlSchema {
     Namespace: string;
     Alias?: string;
@@ -33,5 +33,5 @@ export declare class CsdlSchema {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(base?: Partial<SchemaConfig>): SchemaConfig;
+    toConfig(base?: Partial<ODataSchemaConfig>): ODataSchemaConfig;
 }

package/lib/metadata/csdl/csdl-structural-property.d.ts

@@ -1,4 +1,4 @@
-import { StructuredTypeFieldConfig } from '../../types';
+import { ODataStructuredTypeFieldConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 export declare abstract class CsdlStructuralProperty extends CsdlAnnotable {
     Name: string;
@@ -37,7 +37,7 @@ export declare class CsdlProperty extends CsdlStructuralProperty {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(): StructuredTypeFieldConfig & {
+    toConfig(): ODataStructuredTypeFieldConfig & {
         name: string;
     };
 }
@@ -59,7 +59,7 @@ export declare class CsdlNavigationProperty extends CsdlStructuralProperty {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(): StructuredTypeFieldConfig & {
+    toConfig(): ODataStructuredTypeFieldConfig & {
         name: string;
     };
 }

package/lib/metadata/csdl/csdl-structured-type.d.ts

@@ -1,4 +1,4 @@
-import { StructuredTypeConfig } from '../../types';
+import { ODataStructuredTypeConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import { CsdlProperty, CsdlNavigationProperty } from './csdl-structural-property';
 import type { CsdlSchema } from './csdl-schema';
@@ -39,7 +39,7 @@ export declare class CsdlComplexType extends CsdlStructuredType {
     toJson(): {
         [x: string]: any;
     };
-    toConfig(base?: Partial<StructuredTypeConfig>): StructuredTypeConfig;
+    toConfig(base?: Partial<ODataStructuredTypeConfig>): ODataStructuredTypeConfig;
 }
 export declare class CsdlEntityType extends CsdlStructuredType {
     Key?: CsdlKey;
@@ -58,7 +58,7 @@ export declare class CsdlEntityType extends CsdlStructuredType {
     toJson(): {
         [key: string]: any;
     };
-    toConfig(base?: Partial<StructuredTypeConfig>): StructuredTypeConfig;
+    toConfig(base?: Partial<ODataStructuredTypeConfig>): ODataStructuredTypeConfig;
 }
 export declare class CsdlKey {
     PropertyRef: CsdlPropertyRef[];

package/lib/metadata/metadata.d.ts

@@ -1,13 +1,13 @@
 import { CsdlAction, CsdlFunction } from './csdl/csdl-function-action';
 import { CsdlReference } from './csdl/csdl-reference';
 import { CsdlSchema } from './csdl/csdl-schema';
-import { ApiConfig } from '../types';
+import { ODataApiConfig } from '../types';
 export declare class ODataMetadata {
     Version: string;
     References: CsdlReference[];
     Schemas: CsdlSchema[];
     constructor(Version: string, References: any[], Schemas: any[]);
-    toConfig(base?: Partial<ApiConfig>): ApiConfig;
+    toConfig(base?: Partial<ODataApiConfig>): ODataApiConfig;
     toJson(): {
         Version: string;
         References: {

package/lib/models/options.d.ts

@@ -157,7 +157,7 @@ export declare class ODataModelField<F> {
     }): void;
     isKey(): boolean;
     hasReferentials(): boolean;
-    get referentials(): import("../schema").ODataReferential[];
+    get referentials(): import("angular-odata").ODataReferential[];
     isStructuredType(): boolean;
     structuredType(): ODataStructuredType<F>;
     isEnumType(): boolean;
@@ -200,7 +200,7 @@ export declare class ODataModelAttribute<T> {
     get navigation(): boolean;
     get computed(): boolean | undefined;
     get concurrency(): boolean;
-    get referentials(): import("../schema").ODataReferential[];
+    get referentials(): import("angular-odata").ODataReferential[];
     get options(): ODataModelOptions<any>;
     get name(): string;
     get fieldName(): string;

package/lib/module.d.ts

@@ -1,14 +1,14 @@
 import { EnvironmentProviders, InjectionToken, ModuleWithProviders, Provider } from '@angular/core';
 import { ODataConfigSyncLoader } from './loaders';
-import { ApiConfig } from './types';
+import { ODataApiConfig } from './types';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "@angular/common/http";
 export interface PassedInitialConfig {
-    config?: ApiConfig | ApiConfig[];
+    config?: ODataApiConfig | ODataApiConfig[];
     loader?: Provider;
 }
-export declare const ODATA_CONFIG: InjectionToken<ApiConfig>;
+export declare const ODATA_CONFIG: InjectionToken<ODataApiConfig>;
 export declare function createSyncLoader(passedConfig: PassedInitialConfig): ODataConfigSyncLoader;
 export declare function provideODataClient(passedConfig: PassedInitialConfig): EnvironmentProviders;
 export declare class ODataModule {

package/lib/options.d.ts

@@ -1,5 +1,5 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOption } from './types';
-export declare class ODataApiOptions implements ApiOptions {
+import { ODataApiConfigOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOption } from './types';
+export declare class ODataApiOptions implements ODataApiConfigOptions {
     /**
      * Default OData version
      */
@@ -95,7 +95,7 @@ export declare class ODataApiOptions implements ApiOptions {
          */
         omitNullValues?: boolean;
     };
-    constructor(config: ApiOptions);
+    constructor(config: ODataApiConfigOptions);
     get parserOptions(): ParserOptions;
     get helper(): import("./helper").ODataVersionHelper;
 }

package/lib/resources/query/expressions/apply.d.ts

@@ -49,7 +49,7 @@ export declare class ApplyExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, current?: ApplyExpression<T>): ApplyExpression<T>;
+    static factory<T>(opts: (builder: ApplyExpressionBuilder<T>, current: ApplyExpression<T>) => ApplyExpression<T>, current?: ApplyExpression<T>): ApplyExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

package/lib/resources/query/expressions/compute.d.ts

@@ -13,7 +13,7 @@ export declare class ComputeExpression<T> extends Expression<T> {
         names?: string[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

package/lib/resources/query/expressions/count.d.ts

@@ -34,7 +34,7 @@ export declare class CountExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
+    static factory<T>(opts: (builder: CountExpressionBuilder<T>, current: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
     private _add;
     toJson(): {
         $type: string;

package/lib/resources/query/expressions/expand.d.ts

@@ -30,8 +30,8 @@ export declare class ExpandField<T> implements Renderable {
     expand(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
     filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     search(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
-    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
-    compute(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
+    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    compute(opts: (builder: ComputeExpressionBuilder<T>, current: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     skip(n: number): number;
     top(n: number): number;
     levels(n: number | 'max'): number | "max";
@@ -47,7 +47,7 @@ export declare class ExpandExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -65,4 +65,5 @@ export declare class ExpandExpression<T> extends Expression<T> {
     clone(): ExpandExpression<T>;
     private _add;
     field<F>(field: F, opts?: (e: ExpandField<Unpacked<F>>) => void): ExpandExpression<T>;
+    combine(expression: ExpandExpression<T>): ExpandExpression<T>;
 }

package/lib/resources/query/expressions/filter.d.ts

@@ -19,7 +19,7 @@ export declare class FilterExpression<F> extends Expression<F> {
         negated?: boolean;
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -73,4 +73,5 @@ export declare class FilterExpression<F> extends Expression<F> {
     }) => CountExpression<N>): FilterExpression<F>;
     isof(type: string): FilterExpression<F>;
     isof(left: F, type: string): FilterExpression<F>;
+    combine(exp: FilterExpression<F>, connector?: FilterConnector): FilterExpression<F>;
 }

package/lib/resources/query/expressions/orderby.d.ts

@@ -32,7 +32,7 @@ export declare class OrderByExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     toJson(): {
         $type: string;
@@ -51,4 +51,5 @@ export declare class OrderByExpression<T> extends Expression<T> {
     clone(): OrderByExpression<T>;
     ascending(field: any): OrderByExpression<T>;
     descending(field: any): OrderByExpression<T>;
+    combine(expression: OrderByExpression<T>): OrderByExpression<T>;
 }

package/lib/resources/query/expressions/search.d.ts

@@ -33,7 +33,7 @@ export declare class SearchExpression<T> extends Expression<T> {
         negated?: boolean;
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
+    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
@@ -59,4 +59,5 @@ export declare class SearchExpression<T> extends Expression<T> {
     and(exp: SearchExpression<T>): SearchExpression<T>;
     not(exp: SearchExpression<T>): SearchExpression<T>;
     term(value: any): SearchExpression<T>;
+    combine(expression: SearchExpression<T>, connector?: SearchConnector): SearchExpression<T>;
 }

package/lib/resources/query/expressions/select.d.ts

@@ -11,7 +11,7 @@ export declare class SelectExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -30,4 +30,5 @@ export declare class SelectExpression<T> extends Expression<T> {
     private _add;
     field(field: any): SelectExpression<T>;
     fields(...fields: any[]): SelectExpression<T>;
+    combine(expression: SelectExpression<T>): SelectExpression<T>;
 }

package/lib/resources/query/handlers.d.ts

@@ -1,4 +1,4 @@
-import { Parser, QueryOption } from '../../types';
+import { Parser, ParserOptions, QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, ComputeExpressionBuilder, FilterExpression, FilterExpressionBuilder, OrderByExpression, OrderByExpressionBuilder, SearchExpression, SearchExpressionBuilder, ExpandExpression, ExpandExpressionBuilder, SelectExpression, SelectExpressionBuilder, ApplyExpression, ApplyExpressionBuilder } from './expressions';
 import { ODataQueryArguments, ODataQueryOptions } from './options';
@@ -98,7 +98,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param value The value to raw
      * @returns The raw value
      */
-    raw(value: any): import("./builder").QueryCustomType;
+    raw(value: any): import("angular-odata").QueryCustomType;
     /**
      * Create a new odata alias parameter
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_ParameterAliases
@@ -106,19 +106,19 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param name The name of the alias
      * @returns The alias
      */
-    alias(value: any, name?: string): import("./builder").QueryCustomType;
+    alias(value: any, name?: string): import("angular-odata").QueryCustomType;
     /**
      * Create a duration odata value
      * @param value The value to duration
      * @returns The duration value
      */
-    duration(value: any): import("./builder").QueryCustomType;
+    duration(value: any): import("angular-odata").QueryCustomType;
     /**
      * Create a binary odata value
      * @param value The value to binary
      * @returns The binary value
      */
-    binary(value: any): import("./builder").QueryCustomType;
+    binary(value: any): import("angular-odata").QueryCustomType;
     /**
      * Normalize the given value to a valid odata value
      * @param value The value to normalize
@@ -247,6 +247,11 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param options The query to be applied.
      */
     restore(options: ODataQueryArguments<T>): void;
+    /**
+     * Combine the given query options with the current query.
+     * @param options The query to be combined.
+     */
+    combine(options: ODataQueryArguments<T>): void;
     toJson(): {};
     fromJson(json: {
         [name: string]: any;
@@ -255,4 +260,11 @@ export declare class ODataQueryOptionsHandler<T> {
         escape?: boolean;
         parser?: Parser<T>;
     }): string;
+    pathAndParams({ escape, parser, options, }?: {
+        escape?: boolean;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): [string, {
+        [name: string]: any;
+    }];
 }

package/lib/resources/resource.d.ts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { ODataApi } from '../api';
 import { ModelInterface, ODataCollection, ODataModel } from '../models';
 import { ODataStructuredType } from '../schema';
-import { ParserOptions, QueryOption, StructuredTypeFieldConfig } from '../types';
+import { ParserOptions, QueryOption, ODataStructuredTypeFieldConfig } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler } from './query';
 import { ApplyExpression, ApplyExpressionBuilder, QueryCustomType } from './query';
@@ -35,9 +35,9 @@ export declare class ODataResource<T> {
      * @returns string All covered types of the resource
      */
     types(): string[];
-    callable(): import("../schema").ODataCallable<T> | undefined;
-    enumType(): import("../schema").ODataEnumType<T> | undefined;
-    structuredType(): ODataStructuredType<T> | undefined;
+    callable(): import("angular-odata").ODataCallable<any> | undefined;
+    enumType(): import("angular-odata").ODataEnumType<any> | undefined;
+    structuredType(): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
     /**
      * @returns boolean The resource has key ?
      */
@@ -128,7 +128,7 @@ export declare class ODataResource<T> {
     transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
         type?: string;
         fields?: {
-            [name: string]: StructuredTypeFieldConfig;
+            [name: string]: ODataStructuredTypeFieldConfig;
         };
     }): ODataResource<R>;
     static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;

package/lib/resources/types/action.d.ts

@@ -58,7 +58,7 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
      */
     callModel(params: P | null, options?: ODataOptions & {
         ModelType?: typeof ODataModel;
-    }): Observable<(ODataModel<R> & import("../../models").ModelInterface<R>) | null>;
+    }): Observable<(ODataModel<R> & import("angular-odata").ModelInterface<R>) | null>;
     /**
      * Execute the action and return the result as a entities
      * @param params Parameters for the action
@@ -74,7 +74,7 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
      */
     callCollection(params: P | null, options?: ODataOptions & {
         CollectionType?: typeof ODataCollection;
-    }): Observable<ODataCollection<R, ODataModel<R> & import("../../models").ModelInterface<R>> | null>;
+    }): Observable<ODataCollection<R, ODataModel<R> & import("angular-odata").ModelInterface<R>> | null>;
     callArraybuffer(params: P | null, { alias, ...options }?: {
         alias?: boolean;
     } & ODataOptions): Observable<ArrayBuffer>;