angular-odata 0.78.1 → 0.95.0

package/lib/models/options.d.ts

@@ -1,13 +1,9 @@
-import { Observable, Subscription } from 'rxjs';
-import { ODataStructuredTypeFieldParser } from '../parsers';
-import { Expand, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, EntityKey, ODataResource, ODataSingletonResource, OptionHandler, QueryArguments, Select } from '../resources';
-import { ODataEntitySet, ODataStructuredType } from '../schema';
-import { Options } from '../types';
+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 { Options, OptionsHelper } from '../types';
 import type { ODataCollection } from './collection';
 import type { ODataModel } from './model';
-export declare const CID = "_cid";
-export declare type ODataModelResource<T> = ODataEntityResource<T> | ODataSingletonResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
-export declare type ODataCollectionResource<T> = ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
 export declare class ODataModelEvent<T> {
     name: ODataModelEventType;
@@ -35,11 +31,16 @@ export declare class ODataModelEvent<T> {
     get path(): string;
 }
 export declare const BUBBLING: string[];
-export declare const INCLUDE_ALL: {
-    include_navigation: boolean;
+export declare const INCLUDE_SHALLOW: {
+    include_concurrency: boolean;
+    include_computed: boolean;
+    include_key: boolean;
+};
+export declare const INCLUDE_DEEP: {
     include_concurrency: boolean;
     include_computed: boolean;
     include_key: boolean;
+    include_navigation: boolean;
     include_non_field: boolean;
 };
 export declare enum ODataModelState {
@@ -80,7 +81,7 @@ export declare class ODataModelField<F> {
     name: string;
     field: string;
     parser: ODataStructuredTypeFieldParser<F>;
-    modelOptions: ODataModelOptions<any>;
+    options: ODataModelOptions<any>;
     meta?: ODataModelOptions<any>;
     default?: any;
     required: boolean;
@@ -90,34 +91,35 @@ export declare class ODataModelField<F> {
     min?: number;
     max?: number;
     pattern?: RegExp;
-    constructor(modelOptions: ODataModelOptions<any>, { name, field, parser, ...options }: ODataModelFieldOptions<F>);
+    constructor(options: ODataModelOptions<any>, { name, field, parser, ...opts }: ODataModelFieldOptions<F>);
     get api(): import("angular-odata").ODataApi;
     get type(): string;
     get navigation(): boolean;
     get collection(): boolean;
-    get computed(): boolean;
-    configure({ findOptionsForType, concurrency, }: {
+    annotatedValue<T>(term: string | RegExp): T | undefined;
+    configure({ findOptionsForType, concurrency, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
         concurrency: boolean;
+        options: OptionsHelper;
     }): void;
     isKey(): boolean;
     hasReferentials(): boolean;
-    get referentials(): import("../parsers").ODataReferential[];
+    get referentials(): import("../schema").ODataReferential[];
     isStructuredType(): boolean;
-    structured(): ODataStructuredType<F> | undefined;
+    structured(): ODataStructuredType<F>;
     isEnumType(): boolean;
-    enum(): import("../schema").ODataEnumType<F> | undefined;
+    enum(): import("../schema").ODataEnumType<F>;
     validate(value: any, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): any;
     defaults(): any;
     deserialize(value: any, options?: Options): F;
     serialize(value: F, options?: Options): any;
     encode(value: F, options?: Options): any;
-    resourceFactory<T, F>(resource: ODataModelResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
-    annotationsFactory(annots: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
-    schemaFactory<T, F>(schema: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
+    resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
+    annotationsFactory(base: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
+    schemaFactory<T, F>(base: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
     modelCollectionFactory<T, F>({ parent, value, reset, }: {
         parent: ODataModel<any>;
         value?: F | F[] | {
@@ -130,9 +132,9 @@ export declare class ODataModelField<F> {
 }
 export declare type ODataModelRelation<T> = {
     state: ODataModelState;
-    model: ODataModel<T> | ODataCollection<T, ODataModel<T>> | null;
+    model?: ODataModel<T> | ODataCollection<T, ODataModel<T>> | null;
     field: ODataModelField<T>;
-    subscription: Subscription | null;
+    subscription?: Subscription;
 };
 export declare type ODataModelEntry<T, M extends ODataModel<T>> = {
     state: ODataModelState;
@@ -140,7 +142,7 @@ export declare type ODataModelEntry<T, M extends ODataModel<T>> = {
     key?: EntityKey<T> | {
         [name: string]: any;
     };
-    subscription: Subscription | null;
+    subscription?: Subscription;
 };
 export declare class ODataModelOptions<T> {
     name: string;
@@ -152,71 +154,67 @@ export declare class ODataModelOptions<T> {
     entitySet?: ODataEntitySet;
     parent?: ODataModelOptions<any>;
     children: ODataModelOptions<any>[];
-    constructor(options: ModelOptions, schema: ODataStructuredType<T>);
+    constructor({ options, schema, }: {
+        options: ModelOptions;
+        schema: ODataStructuredType<T>;
+    });
     get api(): import("angular-odata").ODataApi;
     type(): string;
     isTypeOf(type: string): boolean;
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
-    configure({ findOptionsForType, }: {
+    configure({ findOptionsForType, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
+        options: OptionsHelper;
     }): void;
     fields({ include_navigation, include_parents, }?: {
         include_parents?: boolean;
         include_navigation?: boolean;
     }): ODataModelField<any>[];
-    field(name: keyof T | string): ODataModelField<any> | undefined;
-    attach(self: ODataModel<T>, resource: ODataModelResource<T>): void;
+    field<F>(name: keyof T | string): ODataModelField<any>;
+    attach(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
     static chain(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
     ][];
-    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataModelResource<T> | ODataCollectionResource<T>;
-    collectionResourceFactory({ baseResource, }?: {
-        baseResource?: ODataResource<T>;
-    }): ODataCollectionResource<T>;
-    modelResourceFactory({ baseResource, }?: {
-        fromSet?: boolean;
-        baseResource?: ODataResource<T>;
-    }): ODataModelResource<T>;
-    entityResource(self: ODataModel<T>): ODataModelResource<T>;
+    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataResource<T> | ODataResource<T>;
+    collectionResourceFactory(query?: ODataQueryOptions<T>): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | undefined;
+    modelResourceFactory(query?: ODataQueryOptions<T>): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | undefined;
+    entityResource(self: ODataModel<T>): ODataResource<T>;
     bind(self: ODataModel<T>, { parent, resource, annots, }?: {
         parent?: [
             ODataModel<any> | ODataCollection<any, ODataModel<any>>,
             ODataModelField<any> | null
         ];
-        resource?: ODataModelResource<T>;
+        resource?: ODataResource<T>;
         annots?: ODataEntityAnnotations;
     }): void;
-    query(self: ODataModel<T>, resource: ODataModelResource<T>, func: (q: {
-        select(opts?: Select<T>): OptionHandler<Select<T>>;
-        expand(opts?: Expand<T>): OptionHandler<Expand<T>>;
-        format(opts?: string): OptionHandler<string>;
-        apply(query: QueryArguments<T>): void;
-    }) => void): void;
-    resolveKey(value: any, { field_mapping, resolve, }?: {
+    query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>) => void): ODataModel<T>;
+    resolveKey(value: ODataModel<T> | T | {
+        [name: string]: any;
+    }, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): EntityKey<T> | {
         [name: string]: any;
     } | undefined;
-    resolveReferential(self: ODataModel<T> | T | {
+    resolveReferential(value: ODataModel<T> | T | {
         [name: string]: any;
-    }, field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): {
         [name: string]: any;
     } | undefined;
-    resolveReferenced(self: ODataModel<T> | T | {
+    resolveReferenced(value: ODataModel<T> | T | {
         [name: string]: any;
-    }, field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): {
         [name: string]: any;
     } | undefined;
     validate(self: ODataModel<T>, { method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): {
         [name: string]: string[];
@@ -227,7 +225,7 @@ export declare class ODataModelOptions<T> {
     hasChanged(self: ODataModel<T>, { include_navigation }?: {
         include_navigation?: boolean;
     }): boolean;
-    asEntity<R, M extends ODataModel<T>>(self: M, func: (model: M) => Observable<R>): Observable<R>;
+    asEntity<R, M extends ODataModel<T>>(self: M, func: (model: M) => R): R;
     toEntity(self: ODataModel<T>, { client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
         client_id?: boolean;
         include_navigation?: boolean;
@@ -256,8 +254,9 @@ export declare class ODataModelOptions<T> {
     }): void;
     assign(self: ODataModel<T>, entity: Partial<T> | {
         [name: string]: any;
-    }, { reset, silent, }?: {
+    }, { reset, reparent, silent, }?: {
         reset?: boolean;
+        reparent?: boolean;
         silent?: boolean;
     }): void;
     static isModel(obj: any): boolean;
@@ -265,6 +264,8 @@ export declare class ODataModelOptions<T> {
     private updateCollection;
     private updateModel;
     private _get;
+    private _setStructured;
+    private _setValue;
     private _set;
     private _unsubscribe;
     private _subscribe;

package/lib/options.d.ts

@@ -1,32 +1,80 @@
 import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, Options, OptionsHelper, QueryOptionNames } from './types';
 export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
+    /**
+     * Default OData version
+     */
     version: ODataVersion;
+    /**
+     * Send enum as string in the request
+     */
     stringAsEnum?: boolean;
+    /**
+     * Strip metadata from the response
+     */
     stripMetadata: ODataMetadataType;
+    /**
+     * Cache fetch policy
+     */
     fetchPolicy: FetchPolicy;
-    streaming?: boolean;
+    /**
+     * Extra params to be sent in the request
+     */
     params: {
         [param: string]: string | string[];
     };
+    /**
+     * Extra headers to be sent in the request
+     */
     headers: {
         [param: string]: string | string[];
     };
+    /**
+     * Http request with credentials
+     */
     withCredentials?: boolean;
+    /**
+     * Send query options in the request body
+     */
     bodyQueryOptions: QueryOptionNames[];
+    /**
+     * Customize accept header with OData options
+     * @link http://docs.oasis-open.org/odata/odata-json-format/v4.01/odata-json-format-v4.01.html#sec_RequestingtheJSONFormat
+     */
     accept?: {
-        metadata?: ODataMetadataType;
+        exponentialDecimals?: boolean;
         ieee754Compatible?: boolean;
+        metadata?: ODataMetadataType;
+        streaming?: boolean;
     };
     etag: {
+        /**
+         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398229
+         */
         ifMatch: boolean;
+        /**
+         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398230
+         */
         ifNoneMatch: boolean;
     };
     prefer?: {
+        /**
+         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398238
+         */
         maxPageSize?: number;
+        /**
+         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398240
+         */
         return?: 'representation' | 'minimal';
+        /**
+         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398236
+         */
         continueOnError?: boolean;
+        /**
+         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398237
+         */
         includeAnnotations?: string;
     };
+    deleteRefBy: 'path' | 'id';
     constructor(config: ApiOptions);
     get helper(): import("./helper").ODataVersionHelper;
 }

package/lib/resources/index.d.ts

@@ -1,6 +1,5 @@
-export * from './builder';
-export * from './query-options';
-export * from './path-segments';
+export * from './query';
+export * from './path';
 export * from './request';
 export * from './resource';
 export * from './types';

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

@@ -0,0 +1,27 @@
+import { PathSegmentNames } from '../../types';
+import { EntityKey } from '../resource';
+import type { ODataPathSegments, ODataSegment } from './segments';
+export declare class SegmentHandler {
+    private segment;
+    constructor(segment: ODataSegment);
+    get name(): PathSegmentNames;
+    type(value?: string): string | undefined;
+    path(value?: string): string;
+    key<T>(value?: EntityKey<T>): EntityKey<T>;
+    hasKey(): boolean;
+    clearKey(): void;
+    parameters<T>(value?: T): T;
+    hasParameters(): boolean;
+    clearParameters(): void;
+}
+export declare class ODataPathSegmentsHandler<T> {
+    protected segments: ODataPathSegments;
+    constructor(segments: ODataPathSegments);
+    entitySet(): SegmentHandler;
+    singleton(): SegmentHandler;
+    action(): SegmentHandler;
+    function(): SegmentHandler;
+    keys(values?: (EntityKey<T> | undefined)[]): (EntityKey<any> | undefined)[];
+    property(): SegmentHandler;
+    navigationProperty(): SegmentHandler;
+}

package/lib/resources/path/index.d.ts

@@ -0,0 +1,2 @@
+export * from './segments';
+export * from './handlers';

package/lib/resources/{path-segments.d.ts → path/segments.d.ts}

@@ -1,5 +1,6 @@
-import { EntityKey } from './resource';
-import { PathSegmentNames } from '../types';
+import { PathSegmentNames } from '../../types';
+import { EntityKey } from '../resource';
+import { SegmentHandler } from './handlers';
 export declare type ODataSegment = {
     name: PathSegmentNames;
     path: string;
@@ -10,7 +11,7 @@ export declare type ODataSegment = {
 export declare class ODataPathSegments {
     private _segments;
     constructor(segments?: ODataSegment[]);
-    pathAndParams(): [string, {
+    pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     types({ key }?: {
@@ -33,16 +34,3 @@ export declare class ODataPathSegments {
     add(name: string, path: string): SegmentHandler;
     get(name: string): SegmentHandler;
 }
-export declare class SegmentHandler {
-    private segment;
-    constructor(segment: ODataSegment);
-    get name(): PathSegmentNames;
-    type(value?: string): string | undefined;
-    path(value?: string): string;
-    key<T>(value?: EntityKey<T>): EntityKey<T>;
-    hasKey(): boolean;
-    clearKey(): void;
-    parameters<T>(value?: T): T;
-    hasParameters(): boolean;
-    clearParameters(): void;
-}

package/lib/resources/{builder.d.ts → query/builder.d.ts}

@@ -1,7 +1,7 @@
 export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
 export declare type Select<T> = SelectType<T> | SelectType<T>[];
 export declare type SelectType<T> = string | keyof T;
-export declare type Filter = FilterType | FilterType[];
+export declare type Filter<T> = FilterType | FilterType[];
 export declare type FilterType = string | {
     [name: string]: any;
 };
@@ -29,16 +29,16 @@ export declare type NestedExpandOptions<T> = {
 };
 export declare type ExpandOptions<T> = {
     select?: Select<T>;
-    filter?: Filter;
+    filter?: Filter<T>;
     orderBy?: OrderBy<T>;
     top?: number;
     levels?: number | 'max';
-    count?: boolean | Filter;
+    count?: boolean | Filter<T>;
     expand?: Expand<T>;
 };
 export declare type Transform<T> = {
     aggregate?: Aggregate | Array<Aggregate>;
-    filter?: Filter;
+    filter?: Filter<T>;
     groupBy?: GroupBy<T>;
 };
 export declare type GroupBy<T> = {
@@ -74,7 +74,7 @@ export declare type QueryOptions<T> = ExpandOptions<T> & {
     key: string | number | {
         [name: string]: any;
     };
-    count: boolean | Filter;
+    count: boolean | Filter<T>;
     action: string;
     func: string | {
         [functionName: string]: {
@@ -83,9 +83,14 @@ export declare type QueryOptions<T> = ExpandOptions<T> & {
     };
     format: string;
     aliases: QueryCustomType[];
+    escape: boolean;
 };
 export declare const ITEM_ROOT = "";
-export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, }?: Partial<QueryOptions<T>>): string;
-export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, }?: Partial<QueryOptions<T>>): [string, {
+export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): string;
+export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
     [name: string]: any;
 }];
+export declare function normalizeValue(value: Value, { aliases, escape }: {
+    aliases?: QueryCustomType[];
+    escape?: boolean;
+}): any;

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

@@ -0,0 +1,63 @@
+import type { QueryCustomType } from './builder';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare type Connector = 'and' | 'or';
+export declare class Expression<T> implements Renderable {
+    private _connector;
+    private _negated;
+    private _children;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: Connector;
+        negated?: boolean;
+    });
+    get [Symbol.toStringTag](): string;
+    static s<T extends object>(): T;
+    static e<T>(connector?: Connector): Expression<T>;
+    static o<T>(): ODataOperators<T>;
+    static f<T>(): ODataFunctions<T>;
+    static filter<T extends object>(opts: (e: {
+        s: T;
+        e: (connector?: Connector) => Expression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Expression<T>): Expression<T>;
+    toJSON(): {
+        children: any[];
+        connector: Connector;
+        negated: boolean;
+    };
+    children(): Renderable[];
+    connector(): Connector;
+    negated(): boolean;
+    length(): number;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    private _add;
+    or(exp: Expression<T>): Expression<T>;
+    and(exp: Expression<T>): Expression<T>;
+    not(exp: Expression<T>): Expression<T>;
+    eq(left: any, right: any, normalize?: boolean): Expression<T>;
+    ne(left: any, right: any, normalize?: boolean): Expression<T>;
+    gt(left: any, right: any, normalize?: boolean): Expression<T>;
+    ge(left: any, right: any, normalize?: boolean): Expression<T>;
+    lt(left: any, right: any, normalize?: boolean): Expression<T>;
+    le(left: any, right: any, normalize?: boolean): Expression<T>;
+    has(left: any, right: any, normalize?: boolean): Expression<T>;
+    in(left: any, right: any, normalize?: boolean): Expression<T>;
+    contains(left: any, right: any, normalize?: boolean): Expression<T>;
+    startsWith(left: any, right: any, normalize?: boolean): Expression<T>;
+    endsWith(left: any, right: any, normalize?: boolean): Expression<T>;
+    any<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: Connector) => Expression<N>;
+    }) => Expression<N>, alias?: string): Expression<T>;
+    all<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: Connector) => Expression<N>;
+    }) => Expression<N>, alias?: string): Expression<T>;
+    isof(type: string): Expression<T>;
+    isof(left: T, type: string): Expression<T>;
+}

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

@@ -0,0 +1,89 @@
+import { QueryOptionNames } from '../../types';
+import { Expand, Filter, OrderBy, Select, Transform } from './builder';
+import { Connector, Expression } from './expressions';
+import type { ODataQueryArguments, ODataQueryOptions } from './options';
+import { ODataFunctions, ODataOperators } from './syntax';
+export declare class ODataQueryOptionHandler<T> {
+    private o;
+    private n;
+    constructor(o: {
+        [name: string]: any;
+    }, n: QueryOptionNames);
+    get name(): QueryOptionNames;
+    toJSON(): any;
+    empty(): boolean;
+    value(v?: any): any;
+    private assertArray;
+    push(value: any): void;
+    remove(value: any): void;
+    at(index: number): any;
+    private assertObject;
+    set(path: string, value: any): void;
+    get(path: string, def?: any): any;
+    unset(path: string): void;
+    has(path: string): boolean;
+    assign(values: {
+        [attr: string]: any;
+    }): Object;
+    clear(): void;
+}
+export declare class ODataQueryOptionsHandler<T> {
+    protected options: ODataQueryOptions<T>;
+    constructor(options: ODataQueryOptions<T>);
+    /**
+     * 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
+     * @param value The value of the alias
+     * @param name The name of the alias
+     * @returns The alias
+     */
+    alias(value: any, name?: string): import("./builder").QueryCustomType;
+    select(opts: Select<T>): ODataQueryOptionHandler<T>;
+    select(): ODataQueryOptionHandler<T>;
+    expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
+    expand(): ODataQueryOptionHandler<T>;
+    /**
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
+     */
+    compute(opts: (e: {
+        e: Expression<T>;
+    }) => Expression<T>): Expression<T>;
+    compute(opts: string): ODataQueryOptionHandler<T>;
+    compute(): ODataQueryOptionHandler<T>;
+    /**
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat
+     */
+    format(opts: string): ODataQueryOptionHandler<T>;
+    format(): ODataQueryOptionHandler<T>;
+    transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
+    transform(): ODataQueryOptionHandler<T>;
+    search(opts: string): ODataQueryOptionHandler<T>;
+    search(): ODataQueryOptionHandler<T>;
+    filter(opts: (e: {
+        s: T;
+        e: (connector?: Connector) => Expression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Expression<T>): Expression<T>;
+    filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
+    filter(): ODataQueryOptionHandler<T>;
+    orderBy(opts: (e: {
+        e: () => Expression<T>;
+        not: (e: Expression<T>) => Expression<T>;
+    }) => Expression<T>): Expression<T>;
+    orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
+    orderBy(): ODataQueryOptionHandler<T>;
+    top(opts: number): ODataQueryOptionHandler<T>;
+    top(): ODataQueryOptionHandler<T>;
+    skip(opts: number): ODataQueryOptionHandler<T>;
+    skip(): ODataQueryOptionHandler<T>;
+    skiptoken(opts: string): ODataQueryOptionHandler<T>;
+    skiptoken(): ODataQueryOptionHandler<T>;
+    paging({ skip, skiptoken, top, }?: {
+        skip?: number;
+        skiptoken?: string;
+        top?: number;
+    }): void;
+    clearPaging(): void;
+    apply(query: ODataQueryArguments<T>): void;
+}

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

@@ -0,0 +1,3 @@
+export * from './builder';
+export * from './options';
+export * from './handlers';

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

@@ -0,0 +1,38 @@
+import { QueryOptionNames } from '../../types';
+import { Expand, Filter, OrderBy, Select, Transform } from './builder';
+import { Expression } from './expressions';
+import { ODataQueryOptionHandler } from './handlers';
+export declare type ODataQueryArguments<T> = {
+    [QueryOptionNames.select]?: Select<T>;
+    [QueryOptionNames.filter]?: Filter<T>;
+    [QueryOptionNames.search]?: string;
+    [QueryOptionNames.compute]?: string;
+    [QueryOptionNames.transform]?: Transform<T>;
+    [QueryOptionNames.orderBy]?: OrderBy<T>;
+    [QueryOptionNames.top]?: number;
+    [QueryOptionNames.skip]?: number;
+    [QueryOptionNames.skiptoken]?: string;
+    [QueryOptionNames.expand]?: Expand<T>;
+    [QueryOptionNames.format]?: string;
+};
+export declare class ODataQueryOptions<T> {
+    options: {
+        [name: string]: any;
+    };
+    constructor(options?: {
+        [name: string]: any;
+    });
+    pathAndParams(escape?: boolean): [string, {
+        [name: string]: any;
+    }];
+    toString(): string;
+    toJSON(): {};
+    toQueryArguments(): ODataQueryArguments<T>;
+    clone<O>(): ODataQueryOptions<O>;
+    expression(name: QueryOptionNames, exp: Expression<T>): Expression<T>;
+    option<O>(name: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
+    has(name: QueryOptionNames): boolean;
+    remove(...names: QueryOptionNames[]): void;
+    keep(...names: QueryOptionNames[]): void;
+    clear(): void;
+}