angular-odata 0.99.5 → 0.100.0

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 { Options, OptionsHelper } from '../types';
+import { OptionsHelper } 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';
@@ -116,9 +116,9 @@ export declare class ODataModelField<F> {
         navigation?: boolean;
     }): any;
     defaults(): any;
-    deserialize(value: any, options?: Options): F;
-    serialize(value: F, options?: Options): any;
-    encode(value: F, options?: Options): any;
+    deserialize(value: any, options?: OptionsHelper): F;
+    serialize(value: F, options?: OptionsHelper): any;
+    encode(value: F, options?: OptionsHelper): 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;

package/lib/options.d.ts

@@ -1,4 +1,4 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, Options, OptionsHelper, QueryOptionNames } from './types';
+import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, OptionsHelper, QueryOptionNames } from './types';
 export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
     /**
      * Default OData version
@@ -7,7 +7,7 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
     /**
      * Send enum as string in the request
      */
-    stringAsEnum?: boolean;
+    stringAsEnum: boolean;
     /**
      * Strip metadata from the response
      */
@@ -75,12 +75,12 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
         includeAnnotations?: string;
     };
     deleteRefBy: 'path' | 'id';
+    nonParenthesisForEmptyParameterFunction: boolean;
     constructor(config: ApiOptions);
     get helper(): import("./helper").ODataVersionHelper;
 }
 export declare class ODataParserOptions implements OptionsHelper {
     version: ODataVersion;
-    stringAsEnum?: boolean;
-    constructor(config: Options);
+    constructor(config: OptionsHelper);
     get helper(): import("./helper").ODataVersionHelper;
 }

package/lib/resources/resource.d.ts

@@ -59,6 +59,7 @@ export declare class ODataResource<T> {
     endpointUrl(params?: boolean): string;
     toString(): string;
     clone(): ODataResource<T>;
+    private __parser;
     deserialize(value: any, options?: OptionsHelper): any;
     serialize(value: any, options?: OptionsHelper): any;
     encode(value: any, options?: OptionsHelper): any;

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

@@ -1,14 +1,13 @@
-import { ODataMetadataType, ODataVersion, Options, ResponseOptions } from '../../types';
+import { ODataMetadataType, ODataVersion, OptionsHelper, ResponseOptions } from '../../types';
 export declare class ODataResponseOptions implements ResponseOptions {
     version: ODataVersion;
     streaming?: boolean;
     metadata?: ODataMetadataType;
-    stringAsEnum?: boolean;
     ieee754Compatible?: boolean;
     location?: string;
     cacheability?: 'public' | 'private' | 'no-cache' | 'no-store';
     maxAge?: number;
-    constructor(config: Options);
+    constructor(config: OptionsHelper);
     get helper(): import("../../helper").ODataVersionHelper;
     clone(): ODataResponseOptions;
     setFeatures(features: string): void;

package/lib/resources/types/entity-set.d.ts

@@ -40,7 +40,7 @@ export declare class ODataEntitySetResource<T> extends ODataResource<T> {
     fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
-    }): Observable<ODataCollection<T, ODataModel<T>> | null>;
+    }): Observable<C | null>;
     fetchAll(options?: ODataOptions & {
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[]>;

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

@@ -18,6 +18,9 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataFunctionResource<P, R>;
     clone(): ODataFunctionResource<P, R>;
     returnType(): string | undefined;
+    pathAndParams(escape?: boolean): [string, {
+        [name: string]: any;
+    }];
     parameters(params: P | null, { alias }?: {
         alias?: boolean;
     }): ODataFunctionResource<P, R>;

package/lib/schema/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, Options, Parser } from '../types';
+import { CallableConfig, OptionsHelper, Parser } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -18,21 +18,21 @@ export declare class ODataCallable<R> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: Options): any;
+    deserialize(value: any, options?: OptionsHelper): any;
     /**
      * Serialize the given value for the callable.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: any, options?: Options): any;
+    serialize(value: any, options?: OptionsHelper): any;
     /**
      * Encode the given value for the callable.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: any, options?: Options): any;
+    encode(value: any, options?: OptionsHelper): any;
     /**
      * Returns the binding parameter of the callable.
      * @returns The binding parameter of the callable.

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

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, Options } from '../types';
+import { EnumTypeConfig, OptionsHelper } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -46,19 +46,19 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: Options): E;
+    deserialize(value: any, options?: OptionsHelper): E;
     /**
      * Serialize the given value for the enum type.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: E, options?: Options): any;
+    serialize(value: E, options?: OptionsHelper): any;
     /**
      * Encode the given value for the enum type.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: E, options?: Options): any;
+    encode(value: E, options?: OptionsHelper): any;
 }

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

@@ -1,4 +1,4 @@
-import { CallableConfig, Options, OptionsHelper, Parameter, Parser } from '../../types';
+import { CallableConfig, OptionsHelper, Parameter, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {
@@ -9,8 +9,8 @@ export declare class ODataParameterParser<T> {
     nullable?: boolean;
     optionsHelper?: OptionsHelper;
     constructor(name: string, parameter: Parameter);
-    serialize(value: T, options?: Options): any;
-    encode(value: any, options?: Options): string;
+    serialize(value: T, options?: OptionsHelper): any;
+    encode(value: any, options?: OptionsHelper): string;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;
@@ -31,13 +31,15 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     };
     parser: Parser<any>;
     parameters: ODataParameterParser<any>[];
+    nonParenthesisForEmptyParameterFunction?: boolean;
     optionsHelper?: OptionsHelper;
     constructor(config: CallableConfig, namespace: string, alias?: string);
     isTypeOf(type: string): boolean;
-    deserialize(value: any, options?: Options): R;
-    serialize(params: any, options?: Options): any;
-    encode(params: any, options?: Options): any;
-    configure({ parserForType, options, }: {
+    deserialize(value: any, options?: OptionsHelper): R;
+    serialize(params: any, options?: OptionsHelper): any;
+    encode(params: any, options?: OptionsHelper): any;
+    configure({ nonParenthesisForEmptyParameterFunction, parserForType, options, }: {
+        nonParenthesisForEmptyParameterFunction: boolean;
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;
     }): void;

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

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, EnumTypeFieldConfig, Options, OptionsHelper, Parser } from '../../types';
+import { EnumTypeConfig, EnumTypeFieldConfig, OptionsHelper, Parser } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
@@ -17,6 +17,7 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
         [value: number]: string;
     };
     fields: ODataEnumTypeFieldParser[];
+    stringAsEnum?: boolean;
     optionsHelper?: OptionsHelper;
     constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string);
     /**
@@ -26,13 +27,14 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
      * @returns The titleized string.
      */
     ttitelize(term?: string | RegExp): string;
-    configure({ options }: {
+    configure({ stringAsEnum, options }: {
+        stringAsEnum: boolean;
         options: OptionsHelper;
     }): void;
     isTypeOf(type: string): boolean;
-    deserialize(value: string, options?: Options): T;
-    serialize(value: T, options?: Options): string;
-    encode(value: T, options?: Options): any;
+    deserialize(value: string, options?: OptionsHelper): T;
+    serialize(value: T, options?: OptionsHelper): string;
+    encode(value: T, options?: OptionsHelper): any;
     toJsonSchema(): any;
     validate(member: string | number, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';

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

@@ -1,4 +1,4 @@
-import { Options, OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
+import { OptionsHelper, Parser, StructuredTypeConfig, StructuredTypeFieldConfig } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
 declare type JsonSchemaSelect<T> = Array<keyof T>;
@@ -57,10 +57,10 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
         [name: string]: any;
     }[] | string[] | undefined;
     private parse;
-    deserialize(value: any, options?: Options): T;
+    deserialize(value: any, options?: OptionsHelper): T;
     private toJson;
-    serialize(value: T, options?: Options): any;
-    encode(value: T, options?: Options): string;
+    serialize(value: T, options?: OptionsHelper): any;
+    encode(value: T, options?: OptionsHelper): string;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;
@@ -97,9 +97,9 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     isSubtypeOf(type: string): boolean;
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
-    deserialize(value: any, options?: Options): T;
-    serialize(value: T, options?: Options): any;
-    encode(value: T, options?: Options): any;
+    deserialize(value: any, options?: OptionsHelper): T;
+    serialize(value: T, options?: OptionsHelper): any;
+    encode(value: T, options?: OptionsHelper): any;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
         options: OptionsHelper;

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

@@ -1,6 +1,6 @@
 import { ODataCollection } from '../models';
 import { ODataModel } from '../models/model';
-import { Options, StructuredTypeConfig } from '../types';
+import { OptionsHelper, StructuredTypeConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -96,21 +96,21 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: Options): T;
+    deserialize(value: any, options?: OptionsHelper): T;
     /**
      * Serialize the given value for the structured type.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: T, options?: Options): any;
+    serialize(value: T, options?: OptionsHelper): any;
     /**
      * Encode the given value for the structured type.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: T, options?: Options): any;
+    encode(value: T, options?: OptionsHelper): any;
     /**
      * Resolve the key of the structured type for the given value.
      * @param attrs Attributes of the value

package/lib/types.d.ts

@@ -33,11 +33,8 @@ export declare enum QueryOptionNames {
     levels = "levels",
     count = "count"
 }
-export interface Options {
+export interface ApiOptions {
     version?: ODataVersion;
-    stringAsEnum?: boolean;
-}
-export interface ApiOptions extends Options {
     params?: {
         [param: string]: string | string[];
     };
@@ -64,9 +61,12 @@ export interface ApiOptions extends Options {
     stripMetadata?: ODataMetadataType;
     fetchPolicy?: FetchPolicy;
     bodyQueryOptions?: QueryOptionNames[];
+    stringAsEnum?: boolean;
     deleteRefBy?: 'path' | 'id';
+    nonParenthesisForEmptyParameterFunction?: boolean;
 }
-export interface OptionsHelper extends Options {
+export interface OptionsHelper {
+    version?: ODataVersion;
     helper: ODataVersionHelper;
     exponentialDecimals?: boolean;
     metadata?: ODataMetadataType;

package/package.json

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