angular-odata 0.100.1 → 0.102.5

package/lib/api.d.ts

@@ -20,9 +20,7 @@ export declare class ODataApi {
     options: ODataApiOptions;
     cache: ODataCache;
     errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
-    parsers: {
-        [type: string]: Parser<any>;
-    };
+    parsers: Map<string, Parser<any>>;
     schemas: ODataSchema[];
     constructor(config: ApiConfig);
     configure(settings?: {
@@ -96,5 +94,5 @@ export declare class ODataApi {
     findCollectionByName(name: string): typeof ODataCollection | undefined;
     findServiceByName(name: string): typeof ODataEntityService | undefined;
     parserForType<T>(type: string, bindingType?: string): Parser<T>;
-    findOptionsForType<T>(type: string): ODataModelOptions<T> | undefined;
+    findOptionsForType<T>(type: string): ODataModelOptions<any> | ODataModelOptions<T> | undefined;
 }

package/lib/cache/cache.d.ts

@@ -1,6 +1,13 @@
 import { Observable } from 'rxjs';
 import { ODataRequest, ODataResponse } from '../resources';
 import { Cache } 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.
+ * @param lastRead The last read time.
+ * @param timeout The timeout.
+ * @param tags Some tags to identify the entry.
+ */
 export interface ODataCacheEntry<T> {
     payload: T;
     lastRead: number;
@@ -15,28 +22,82 @@ export declare abstract class ODataCache implements Cache {
     });
     abstract getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
     abstract putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+    /**
+     * Using the resource on the request build an array of string to identify the scope of the request
+     * @param req The request with the resource to build the scope
+     * @returns Array of string to identify the scope of the request
+     */
     scope(req: ODataRequest<any>): string[];
-    tags(req: ODataRequest<any>, res: ODataResponse<any>): string[];
+    /**
+     * Using the odata context on the response build an array of string to identify the tags of the response
+     * @param res The response to build the tags
+     * @returns Array of string to identify the tags of the response
+     */
+    tags(res: ODataResponse<any>): string[];
+    /**
+     * Build an entry from a payload and some options
+     * @param payload The payload to store in the cache
+     * @param timeout The timeout for the entry
+     * @param tags The tags for the entry
+     * @returns The entry to store in the cache
+     */
     buildEntry<T>(payload: T, { timeout, tags }: {
         timeout?: number;
         tags?: string[];
     }): ODataCacheEntry<T>;
+    /**
+     * Build a key from store an entry in the cache
+     * @param names The names of the entry
+     * @returns The key for the entry
+     */
     buildKey(names: string[]): string;
+    /**
+     * Put some payload in the cache
+     * @param name The name for the entry
+     * @param payload The payload to store in the cache
+     * @param timeout The timeout for the entry
+     * @param scope The scope for the entry
+     * @param tags The tags for the entry
+     */
     put<T>(name: string, payload: T, { timeout, scope, tags, }?: {
         timeout?: number;
         scope?: string[];
         tags?: string[];
     }): void;
+    /**
+     * Return the payload from the cache if it exists and is not expired
+     * @param name The name of the entry
+     * @param scope The scope of the entry
+     * @returns The payload of the entry
+     */
     get<T>(name: string, { scope }?: {
         scope?: string[];
     }): T;
+    /**
+     * Remove all cache entries that are matching with the given options
+     * @param options The options to forget
+     */
     forget({ name, scope, tags, }?: {
         name?: string;
         scope?: string[];
         tags?: string[];
     }): void;
+    /**
+     * Remove all cache entries
+     */
     flush(): void;
+    /**
+     * Check if the entry is expired
+     * @param entry The cache entry
+     * @returns Boolean indicating if the entry is expired
+     */
     isExpired(entry: ODataCacheEntry<any>): boolean;
+    /**
+     * Using the request, handle the fetching of the response
+     * @param req The request to fetch
+     * @param res$ Observable of the response
+     * @returns
+     */
     handleRequest(req: ODataRequest<any>, res$: Observable<ODataResponse<any>>): Observable<ODataResponse<any>>;
     private handleFetch;
     private handleMutate;

package/lib/cache/memory.d.ts

@@ -4,6 +4,16 @@ export declare class ODataInMemoryCache extends ODataCache {
     constructor({ timeout }?: {
         timeout?: number;
     });
+    /**
+     * Store the response in the cache
+     * @param req The request with the resource to store the response
+     * @param res The response to store in the cache
+     */
     putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+    /**
+     * Restore the response from the cache
+     * @param req The request with the resource to get the response
+     * @returns The response from the cache
+     */
     getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
 }

package/lib/cache/storage.d.ts

@@ -8,9 +8,28 @@ export declare class ODataInStorageCache extends ODataCache {
         name: string;
         storage?: Storage;
     });
+    /**
+     * Store the cache in the storage
+     */
     store(): void;
+    /**
+     * Restore the cache from the storage
+     */
     restore(): void;
+    /**
+     * Flush the cache and clean the storage
+     */
     flush(): void;
+    /**
+     * Store the response in the cache
+     * @param req The request with the resource to store the response
+     * @param res The response to store in the cache
+     */
     putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+    /**
+     * Restore the response from the cache
+     * @param req The request with the resource to get the response
+     * @returns The response from the cache
+     */
     getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
 }

package/lib/constants.d.ts

@@ -42,6 +42,7 @@ export declare const BINARY = "binary";
 export declare const BOUNDARY_PREFIX_SUFFIX = "--";
 export declare const BATCH_PREFIX = "batch_";
 export declare const CHANGESET_PREFIX = "changeset_";
+export declare const DEFAULT_METADATA = "minimal";
 export declare const DEFAULT_STRIP_METADATA = "full";
 export declare const DEFAULT_FETCH_POLICY = "network-only";
 export declare const DEFAULT_TIMEOUT = 60;

package/lib/models/collection.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
-import { ODataEntitiesAnnotations, ODataEntitySetResource, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource } from '../resources';
+import { ODataActionOptions, ODataEntitiesAnnotations, ODataEntitySetResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryOptionsHandler, ODataResource } from '../resources';
+import { ODataStructuredType } from '../schema/structured-type';
 import { ODataModel } from './model';
 import { ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
 export declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
@@ -68,19 +69,20 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     private addReference;
     private _addModel;
     private addModel;
-    add(model: M, { silent, reparent, server, position, }?: {
+    add(model: M, { silent, reparent, server, merge, position, }?: {
         silent?: boolean;
         reparent?: boolean;
         server?: boolean;
+        merge?: boolean;
         position?: number;
-    }): Observable<this>;
+    }): Observable<M>;
     private removeReference;
     private _removeModel;
     private removeModel;
     remove(model: M, { silent, server, }?: {
         silent?: boolean;
         server?: boolean;
-    }): Observable<this>;
+    }): Observable<M>;
     create(attrs?: T, { silent, server, }?: {
         silent?: boolean;
         server?: boolean;
@@ -92,6 +94,9 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         path?: string | string[];
         silent?: boolean;
     }): void;
+    clear({ silent }?: {
+        silent?: boolean;
+    }): void;
     assign(objects: Partial<T>[] | {
         [name: string]: any;
     }[] | M[], { reset, reparent, silent, }?: {
@@ -99,11 +104,11 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         reparent?: boolean;
         silent?: boolean;
     }): void;
-    query(func: (q: ODataQueryOptionsHandler<T>) => void): this;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    private _unsubscribe;
-    private _subscribe;
+    query(func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
+    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    private _unlink;
+    private _link;
     private _findEntry;
     equals(other: ODataCollection<T, ODataModel<T>>): boolean;
     get [Symbol.toStringTag](): string;

package/lib/models/model.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
-import { EntityKey, ODataEntityAnnotations, ODataEntityResource, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
+import { EntityKey, ODataActionOptions, ODataEntityAnnotations, ODataEntityResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataStructuredType } from '../schema';
 import { ODataCollection } from './collection';
 import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelRelation } from './options';
@@ -55,13 +55,13 @@ export declare class ODataModel<T> {
         resolve?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     referenced(field: ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     _errors?: {
         [key: string]: any;
     };
@@ -109,6 +109,9 @@ export declare class ODataModel<T> {
         path?: string | string[];
         silent?: boolean;
     }): void;
+    clear({ silent }?: {
+        silent?: boolean;
+    }): void;
     assign(entity: Partial<T> | {
         [name: string]: any;
     }, { reset, reparent, silent, }?: {
@@ -134,7 +137,7 @@ export declare class ODataModel<T> {
      * Create an execution context for change the internal query of a resource
      * @param func Function to execute
      */
-    query(func: (q: ODataQueryOptionsHandler<T>) => void): this;
+    query(func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     /**
      * Perform a check on the internal state of the model and return true if the model is changed.
      * @param include_navigation Check in navigation properties
@@ -149,13 +152,13 @@ export declare class ODataModel<T> {
      * @returns The result of the context
      */
     asEntity<R>(ctx: (model: this) => R): R;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
     cast<S>(type: string): ODataModel<S>;
     fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', { ...options }?: {} & ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
     getValue<P>(name: keyof T | string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
     setReference<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
-    getReference<P>(name: keyof T | string): ODataModel<P> | ODataCollection<P, ODataModel<P>>;
+    getReference<P>(name: keyof T | string): ODataModel<P> | ODataCollection<P, ODataModel<P>> | null;
     equals(other: ODataModel<T>): boolean;
     get [Symbol.toStringTag](): string;
     collection(): ODataCollection<T, ODataModel<T>> | undefined;

package/lib/models/options.d.ts

@@ -1,7 +1,7 @@
 import { Subscription } from 'rxjs';
 import { EntityKey, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, ODataQueryOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataEntitySet, ODataStructuredType, ODataStructuredTypeFieldParser } from '../schema';
-import { OptionsHelper } from '../types';
+import { ParserOptions } from '../types';
 import type { ODataCollection } from './collection';
 import type { ODataModel } from './model';
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
@@ -10,10 +10,10 @@ export declare class ODataModelEvent<T> {
     value?: any;
     previous?: any;
     options?: any;
-    constructor(name: ODataModelEventType, { model, collection, previous, value, track, options, }?: {
+    constructor(name: ODataModelEventType, { model, collection, previous, value, field, options, }?: {
         model?: ODataModel<T>;
         collection?: ODataCollection<T, ODataModel<T>>;
-        track?: string | number;
+        field?: ODataModelField<any> | number;
         previous?: any;
         value?: any;
         options?: any;
@@ -22,9 +22,9 @@ export declare class ODataModelEvent<T> {
     stopPropagation(): void;
     chain: [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
-        string | number | null
+        ODataModelField<any> | number | null
     ][];
-    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, track: string | number): void;
+    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, field: ODataModelField<any> | number): ODataModelEvent<T>;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     get path(): string;
     model?: ODataModel<T>;
@@ -93,6 +93,7 @@ export declare class ODataModelField<F> {
     min?: number;
     max?: number;
     pattern?: RegExp;
+    parserOptions?: ParserOptions;
     constructor(options: ODataModelOptions<any>, { name, field, parser, ...opts }: ODataModelFieldOptions<F>);
     get api(): import("angular-odata").ODataApi;
     get type(): string;
@@ -102,7 +103,7 @@ export declare class ODataModelField<F> {
     configure({ findOptionsForType, concurrency, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
         concurrency: boolean;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     isKey(): boolean;
     hasReferentials(): boolean;
@@ -116,9 +117,9 @@ export declare class ODataModelField<F> {
         navigation?: boolean;
     }): any;
     defaults(): any;
-    deserialize(value: any, options?: OptionsHelper): F;
-    serialize(value: F, options?: OptionsHelper): any;
-    encode(value: F, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): F;
+    serialize(value: F, options?: ParserOptions): any;
+    encode(value: F, options?: ParserOptions): any;
     resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
     annotationsFactory(base: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
     schemaFactory<T, F>(base: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
@@ -161,16 +162,21 @@ export declare class ODataModelOptions<T> {
         schema: ODataStructuredType<T>;
     });
     get api(): import("angular-odata").ODataApi;
-    type(): string;
+    type({ alias }?: {
+        alias?: boolean;
+    }): string;
     isTypeOf(type: string): boolean;
+    isModelFor(entity: T | {
+        [name: string]: any;
+    }): boolean;
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
     configure({ findOptionsForType, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
-    fields({ include_navigation, include_parents, }?: {
-        include_parents?: boolean;
-        include_navigation?: boolean;
+    fields({ include_navigation, include_parents, }: {
+        include_parents: boolean;
+        include_navigation: boolean;
     }): ODataModelField<any>[];
     field<F>(name: keyof T | string): ODataModelField<F>;
     attach<R>(self: ODataModel<T>, resource: ODataEntityResource<R> | ODataNavigationPropertyResource<R> | ODataPropertyResource<R> | ODataSingletonResource<R>): void;
@@ -190,31 +196,34 @@ export declare class ODataModelOptions<T> {
         resource?: ODataResource<T>;
         annots?: ODataEntityAnnotations;
     }): void;
-    query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>) => void): ODataModel<T>;
+    query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): ODataModel<T>;
     resolveKey(value: ODataModel<T> | T | {
         [name: string]: any;
-    }, { field_mapping, resolve, }?: {
+    }, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
+        single?: boolean;
     }): EntityKey<T> | {
         [name: string]: any;
     } | undefined;
     resolveReferential(value: ODataModel<T> | T | {
         [name: string]: any;
-    } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    } | null, field: ODataModelField<any>, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
+        single?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     resolveReferenced(value: ODataModel<T> | T | {
         [name: string]: any;
-    } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    } | null, field: ODataModelField<any>, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
+        single?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     validate(self: ODataModel<T>, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -269,6 +278,6 @@ export declare class ODataModelOptions<T> {
     private _setStructured;
     private _setValue;
     private _set;
-    private _unsubscribe;
-    private _subscribe;
+    private _unlink;
+    private _link;
 }

package/lib/options.d.ts

@@ -1,5 +1,5 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, OptionsHelper, QueryOptionNames } from './types';
-export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
+import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOptionNames } from './types';
+export declare class ODataApiOptions implements ApiOptions {
     /**
      * Default OData version
      */
@@ -77,10 +77,6 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
     deleteRefBy: 'path' | 'id';
     nonParenthesisForEmptyParameterFunction: boolean;
     constructor(config: ApiOptions);
-    get helper(): import("./helper").ODataVersionHelper;
-}
-export declare class ODataParserOptions implements OptionsHelper {
-    version: ODataVersion;
-    constructor(config: OptionsHelper);
+    get parserOptions(): ParserOptions;
     get helper(): import("./helper").ODataVersionHelper;
 }

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

@@ -59,7 +59,7 @@ export declare type QueryCustomType = {
 };
 export declare type Value = string | Date | number | boolean | QueryCustomType;
 export declare const raw: (value: string) => QueryCustomType;
-export declare const alias: (value: any, name?: string | undefined) => QueryCustomType;
+export declare const alias: (value: any, name?: string) => QueryCustomType;
 export declare const duration: (value: string) => QueryCustomType;
 export declare const binary: (value: string) => QueryCustomType;
 export declare const isQueryCustomType: (value: any) => boolean;

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

@@ -1,18 +1,19 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare type ComputeExpressionBuilder<T> = {
+    t: T;
+    e: () => ComputeExpression<T>;
+};
 export declare class ComputeExpression<T> extends Expression<T> {
     names: string[];
     constructor({ children, names, }?: {
         children?: Renderable[];
         names?: string[];
     });
-    static e<T>(): ComputeExpression<T>;
-    static s<T extends object>(): T;
-    static compute<T extends object>(opts: (builder: {
-        s: T;
-        e: () => ComputeExpression<T>;
-    }, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    static expression<T>(): ComputeExpression<T>;
+    static type<T extends object>(): T;
+    static compute<T extends object>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;

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

@@ -1,10 +1,10 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { FilterConnector, FilterExpression } from './filter';
-import { OrderByExpression } from './orderby';
-import { SearchConnector, SearchExpression } from './search';
-import { SelectExpression } from './select';
-import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+import { FilterExpression, FilterExpressionBuilder } from './filter';
+import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
+import { SearchExpression, SearchExpressionBuilder } from './search';
+import { SelectExpression, SelectExpressionBuilder } from './select';
+import { Renderable } from './syntax';
 export declare class ExpandField<T> implements Renderable {
     protected field: any;
     private values;
@@ -21,42 +21,27 @@ export declare class ExpandField<T> implements Renderable {
         prefix?: string;
     }): string;
     clone(): ExpandField<unknown>;
-    select<T extends object>(opts: (builder: {
-        s: T;
-        e: () => SelectExpression<T>;
-    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
-    expand<T extends object>(opts: (builder: {
-        s: T;
-        e: () => ExpandExpression<T>;
-    }, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
-    filter<T extends object>(opts: (builder: {
-        s: T;
-        e: (connector?: FilterConnector) => FilterExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: FilterExpression<T>) => FilterExpression<T>): any;
-    search<T extends object>(opts: (builder: {
-        e: (connector?: SearchConnector) => SearchExpression<T>;
-    }) => SearchExpression<T>): any;
-    orderBy<T extends object>(opts: (builder: {
-        s: T;
-        e: () => OrderByExpression<T>;
-    }, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
+    select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
+    filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
+    search<T extends object>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): any;
+    orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
     skip(n: number): any;
     top(n: number): any;
     levels(n: number | 'max'): any;
     private option;
 }
+export declare type ExpandExpressionBuilder<T> = {
+    t: T;
+    e: () => ExpandExpression<T>;
+};
 export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static e<T>(): ExpandExpression<T>;
-    static s<T extends object>(): T;
-    static expand<T extends object>(opts: (builder: {
-        s: T;
-        e: () => ExpandExpression<T>;
-    }, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    static expression<T>(): ExpandExpression<T>;
+    static type<T extends object>(): T;
+    static expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;

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

@@ -2,6 +2,12 @@ import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type FilterConnector = 'and' | 'or';
+export declare type FilterExpressionBuilder<T> = {
+    t: T;
+    e: (connector?: FilterConnector) => FilterExpression<T>;
+    o: ODataOperators<T>;
+    f: ODataFunctions<T>;
+};
 export declare class FilterExpression<F> extends Expression<F> {
     private _connector;
     private _negated;
@@ -10,14 +16,9 @@ export declare class FilterExpression<F> extends Expression<F> {
         connector?: FilterConnector;
         negated?: boolean;
     });
-    static s<T extends object>(): T;
-    static e<T>(connector?: FilterConnector): FilterExpression<T>;
-    static filter<T extends object>(opts: (builder: {
-        s: T;
-        e: (connector?: FilterConnector) => FilterExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    static type<T extends object>(): T;
+    static expression<T>(connector?: FilterConnector): FilterExpression<T>;
+    static filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJSON(): {
         children: any[];
         connector: FilterConnector;
@@ -47,11 +48,11 @@ export declare class FilterExpression<F> extends Expression<F> {
     startsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
     endsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
     any<N extends object>(left: N[], opts: (e: {
-        s: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
+        t: N;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     all<N extends object>(left: N[], opts: (e: {
-        s: N;
+        t: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     isof(type: string): FilterExpression<F>;

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

@@ -3,4 +3,6 @@ export * from './compute';
 export * from './filter';
 export * from './orderby';
 export * from './search';
+export * from './select';
 export * from './syntax';
+export * from './expand';

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

@@ -17,16 +17,17 @@ export declare class OrderByField implements Renderable {
     }): string;
     clone(): OrderByField;
 }
+export declare type OrderByExpressionBuilder<T> = {
+    t: T;
+    e: () => OrderByExpression<T>;
+};
 export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static e<T>(): OrderByExpression<T>;
-    static s<T extends object>(): T;
-    static orderBy<T extends object>(opts: (builder: {
-        s: T;
-        e: () => OrderByExpression<T>;
-    }, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    static expression<T>(): OrderByExpression<T>;
+    static type<T extends object>(): T;
+    static orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;