angular-odata 0.102.5 → 0.105.0

package/lib/helper.d.ts

@@ -22,6 +22,9 @@ export interface ODataVersionHelper {
     ODATA_ETAG: string;
     ODATA_CONTEXT: string;
     ODATA_MEDIA_ETAG: string;
+    ODATA_NEXTLINK: string;
+    ODATA_DEFERRED: string;
+    ODATA_ANNOTATION: string;
     entity(value: {
         [key: string]: any;
     }): any;

package/lib/models/collection.d.ts

@@ -16,6 +16,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     _model: typeof ODataModel;
     models(): M[];
     get length(): number;
+    isEmpty(): boolean;
     events$: EventEmitter<ODataModelEvent<T>>;
     constructor(entities?: Partial<T>[] | {
         [name: string]: any;
@@ -42,10 +43,10 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         changes_only?: boolean;
         field_mapping?: boolean;
         chain?: (ODataModel<any> | ODataCollection<any, ODataModel<any>>)[];
-    }): (T | {
+    }): (Partial<T> | {
         [name: string]: any;
     })[];
-    toJSON(): (T | {
+    toJSON(): (Partial<T> | {
         [name: string]: any;
     })[];
     hasChanged({ include_navigation }?: {

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 { ParserOptions } from '../types';
+import { Parser, 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';
@@ -123,11 +123,16 @@ export declare class ODataModelField<F> {
     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, }: {
+    modelFactory<F>({ parent, value, reset, }: {
         parent: ODataModel<any>;
-        value?: F | F[] | {
+        value?: Partial<F> | {
             [name: string]: any;
-        } | {
+        };
+        reset?: boolean;
+    }): ODataModel<F>;
+    collectionFactory<F>({ parent, value, reset, }: {
+        parent: ODataModel<any>;
+        value?: Partial<F>[] | {
             [name: string]: any;
         }[];
         reset?: boolean;
@@ -170,9 +175,10 @@ export declare class ODataModelOptions<T> {
         [name: string]: any;
     }): boolean;
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
-    configure({ findOptionsForType, options, }: {
-        findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
+    configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
     }): void;
     fields({ include_navigation, include_parents, }: {
         include_parents: boolean;

package/lib/options.d.ts

@@ -8,6 +8,14 @@ export declare class ODataApiOptions implements ApiOptions {
      * Send enum as string in the request
      */
     stringAsEnum: boolean;
+    /**
+     * Delete reference by path or by id
+     */
+    deleteRefBy: 'path' | 'id';
+    /**
+     * No use parenthesis for empty parameters functions
+     */
+    nonParenthesisForEmptyParameterFunction: boolean;
     /**
      * Strip metadata from the response
      */
@@ -74,8 +82,6 @@ export declare class ODataApiOptions implements ApiOptions {
          */
         includeAnnotations?: string;
     };
-    deleteRefBy: 'path' | 'id';
-    nonParenthesisForEmptyParameterFunction: boolean;
     constructor(config: ApiOptions);
     get parserOptions(): ParserOptions;
     get helper(): import("./helper").ODataVersionHelper;

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

@@ -2,7 +2,7 @@ import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type ComputeExpressionBuilder<T> = {
-    t: T;
+    t: Required<Readonly<T>>;
     e: () => ComputeExpression<T>;
 };
 export declare class ComputeExpression<T> extends Expression<T> {
@@ -11,8 +11,6 @@ export declare class ComputeExpression<T> extends Expression<T> {
         children?: Renderable[];
         names?: string[];
     });
-    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;

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

@@ -32,15 +32,13 @@ export declare class ExpandField<T> implements Renderable {
     private option;
 }
 export declare type ExpandExpressionBuilder<T> = {
-    t: T;
+    t: Readonly<Required<T>>;
     e: () => ExpandExpression<T>;
 };
 export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    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;

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

@@ -3,7 +3,7 @@ import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type FilterConnector = 'and' | 'or';
 export declare type FilterExpressionBuilder<T> = {
-    t: T;
+    t: Readonly<Required<T>>;
     e: (connector?: FilterConnector) => FilterExpression<T>;
     o: ODataOperators<T>;
     f: ODataFunctions<T>;
@@ -16,8 +16,6 @@ export declare class FilterExpression<F> extends Expression<F> {
         connector?: FilterConnector;
         negated?: boolean;
     });
-    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[];
@@ -47,7 +45,7 @@ export declare class FilterExpression<F> extends Expression<F> {
     contains(left: any, right: any, normalize?: boolean): FilterExpression<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: {
+    any<N extends object>(left: N[], opts?: (e: {
         e: (connector?: FilterConnector) => FilterExpression<N>;
         t: N;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;

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

@@ -18,15 +18,13 @@ export declare class OrderByField implements Renderable {
     clone(): OrderByField;
 }
 export declare type OrderByExpressionBuilder<T> = {
-    t: T;
+    t: Readonly<Required<T>>;
     e: () => OrderByExpression<T>;
 };
 export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    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, }?: {

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

@@ -28,7 +28,6 @@ export declare class SearchExpression<T> extends Expression<T> {
         connector?: SearchConnector;
         negated?: boolean;
     });
-    static expression<T>(connector?: SearchConnector): SearchExpression<T>;
     static search<T extends object>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {

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

@@ -2,15 +2,13 @@ import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
 export declare type SelectExpressionBuilder<T> = {
-    t: T;
+    t: Readonly<Required<T>>;
     e: () => SelectExpression<T>;
 };
 export declare class SelectExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static expression<T>(): SelectExpression<T>;
-    static type<T extends object>(): T;
     static select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;

package/lib/resources/responses/annotations.d.ts

@@ -8,6 +8,9 @@ export declare abstract class ODataAnnotations {
     attributes<T>(data: {
         [key: string]: any;
     }, metadata: ODataMetadataType): T;
+    update(data: {
+        [key: string]: any;
+    }): void;
     get entitySet(): string | undefined;
     get type(): string | undefined;
     abstract clone(): ODataAnnotations;

package/lib/schema/callable.d.ts

@@ -9,8 +9,10 @@ export declare class ODataCallable<R> extends ODataSchemaElement {
     parser: ODataCallableParser<R>;
     constructor(config: CallableConfig, schema: ODataSchema);
     path(): string;
-    configure({ parserForType, }: {
+    configure({ options, parserForType, findOptionsForType, }: {
+        options: ParserOptions;
         parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
     }): void;
     /**
      * Deseialize the given value from the callable.

package/lib/schema/enum-type.d.ts

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, ParserOptions } from '../types';
+import { EnumTypeConfig, Parser, ParserOptions } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -10,7 +10,11 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
         [value: number]: string;
     };
     constructor(config: EnumTypeConfig<E>, schema: ODataSchema);
-    configure(): void;
+    configure({ options, parserForType, findOptionsForType, }: {
+        options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
+    }): void;
     /**
      * Returns the fields of the enum type.
      * @returns The fields of the enum type.
@@ -49,4 +53,6 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * @returns Encoded value
      */
     encode(value: E, options?: ParserOptions): any;
+    unpack(value: E): number[];
+    pack(value: number[]): E;
 }

package/lib/schema/parsers/callable.d.ts

@@ -11,9 +11,10 @@ export declare class ODataParameterParser<T> {
     constructor(name: string, parameter: Parameter);
     serialize(value: T, options?: ParserOptions): any;
     encode(value: any, options?: ParserOptions): string;
-    configure({ parserForType, options, }: {
-        parserForType: (type: string) => Parser<any>;
+    configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
     }): void;
     isEdmType(): boolean;
     isEnumType(): boolean;
@@ -32,17 +33,16 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     };
     parser: Parser<any>;
     parameters: ODataParameterParser<any>[];
-    nonParenthesisForEmptyParameterFunction?: boolean;
     parserOptions?: ParserOptions;
     constructor(config: CallableConfig, namespace: string, alias?: string);
     isTypeOf(type: string): boolean;
     deserialize(value: any, options?: ParserOptions): R;
     serialize(params: any, options?: ParserOptions): any;
     encode(params: any, options?: ParserOptions): any;
-    configure({ nonParenthesisForEmptyParameterFunction, parserForType, options, }: {
-        nonParenthesisForEmptyParameterFunction: boolean;
-        parserForType: (type: string) => Parser<any>;
+    configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
     }): void;
     binding(): ODataParameterParser<any> | undefined;
 }

package/lib/schema/parsers/enum-type.d.ts

@@ -17,19 +17,12 @@ export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements
         [value: number]: string;
     };
     private _fields;
-    stringAsEnum?: boolean;
     parserOptions?: ParserOptions;
     constructor(config: EnumTypeConfig<E>, namespace: string, alias?: string);
-    /**
-     * Create a nicer looking title.
-     * Titleize is meant for creating pretty output.
-     * @param term The term of the annotation to find.
-     * @returns The titleized string.
-     */
-    ttitelize(term?: string | RegExp): string;
-    configure({ stringAsEnum, options, }: {
-        stringAsEnum: boolean;
+    configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
     }): void;
     isTypeOf(type: string): boolean;
     fields(value?: E): ODataEnumTypeFieldParser<E>[];
@@ -48,4 +41,6 @@ export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): string[] | undefined;
+    unpack(value: E): number[];
+    pack(value: number[]): E;
 }

package/lib/schema/parsers/structured-type.d.ts

@@ -44,7 +44,7 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     nullable: boolean;
     navigation: boolean;
     precision?: number;
-    scale?: number;
+    scale?: number | 'variable';
     referentials: ODataReferential[];
     parserOptions?: ParserOptions;
     constructor(name: string, structuredType: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
@@ -61,9 +61,10 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     private toJson;
     serialize(value: T, options?: ParserOptions): any;
     encode(value: T, options?: ParserOptions): string;
-    configure({ parserForType, options, }: {
-        parserForType: (type: string) => Parser<any>;
+    configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
     }): void;
     toJsonSchema(options?: JsonSchemaOptions<T>): any;
     isKey(): boolean;
@@ -101,9 +102,10 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     deserialize(value: any, options?: ParserOptions): T;
     serialize(value: T, options?: ParserOptions): any;
     encode(value: T, options?: ParserOptions): any;
-    configure({ parserForType, options, }: {
-        parserForType: (type: string) => Parser<any>;
+    configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
+        findOptionsForType: (type: string) => any;
     }): void;
     /**
      * Returns all fields of the structured type.

package/lib/schema/schema.d.ts

@@ -1,5 +1,5 @@
 import { ODataApi } from '../api';
-import { Parser, SchemaConfig } from '../types';
+import { Parser, ParserOptions, SchemaConfig } from '../types';
 import { ODataAnnotatable } from './annotation';
 import { ODataCallable } from './callable';
 import { ODataEntityContainer } from './entity-container';
@@ -21,7 +21,8 @@ export declare class ODataSchema extends ODataAnnotatable {
     findStructuredTypeForType<T>(type: string): ODataStructuredType<T> | undefined;
     findCallableForType<T>(type: string, bindingType?: string): ODataCallable<T> | undefined;
     findEntitySetForType(type: string): ODataEntitySet | undefined;
-    configure({ parserForType, findOptionsForType, }: {
+    configure({ options, parserForType, findOptionsForType, }: {
+        options: ParserOptions;
         parserForType: (type: string) => Parser<any>;
         findOptionsForType: (type: string) => any;
     }): void;

package/lib/schema/structured-type.d.ts

@@ -1,6 +1,6 @@
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
-import { ParserOptions, StructuredTypeConfig } from '../types';
+import { Parser, ParserOptions, StructuredTypeConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -13,8 +13,9 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
     collection?: typeof ODataCollection;
     parser: ODataStructuredTypeParser<T>;
     constructor(config: StructuredTypeConfig<T>, schema: ODataSchema);
-    configure({ parserForType, findOptionsForType, }: {
-        parserForType: (type: string) => any;
+    configure({ options, parserForType, findOptionsForType, }: {
+        options: ParserOptions;
+        parserForType: (type: string) => Parser<any>;
         findOptionsForType: (type: string) => any;
     }): void;
     /**

package/lib/types.d.ts

@@ -70,6 +70,9 @@ export interface ParserOptions {
     metadata?: ODataMetadataType;
     ieee754Compatible?: boolean;
     streaming?: boolean;
+    stringAsEnum?: boolean;
+    deleteRefBy?: 'path' | 'id';
+    nonParenthesisForEmptyParameterFunction?: boolean;
 }
 export interface ResponseOptions extends ParserOptions {
     cacheability?: CacheCacheability;
@@ -151,7 +154,7 @@ export declare type StructuredTypeFieldConfig = {
     navigation?: boolean;
     precision?: number;
     annotations?: AnnotationConfig[];
-    scale?: number;
+    scale?: number | 'variable';
     referentials?: {
         property: string;
         referencedProperty: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.102.5",
+  "version": "0.105.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {