angular-odata 0.99.0 → 0.100.0

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

@@ -17,6 +17,7 @@ export declare class ODataEntitySetResource<T> extends ODataResource<T> {
         schema?: ODataStructuredType<E>;
         query?: ODataQueryOptions<E>;
     }): ODataEntitySetResource<E>;
+    clone(): ODataEntitySetResource<T>;
     entity(key?: any): ODataEntityResource<T>;
     action<P, R>(path: string): ODataActionResource<P, R>;
     function<P, R>(path: string): ODataFunctionResource<P, R>;
@@ -39,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/entity.d.ts

@@ -19,6 +19,7 @@ export declare class ODataEntityResource<T> extends ODataResource<T> {
         segments: ODataPathSegments;
         query?: ODataQueryOptions<E>;
     }): ODataEntityResource<E>;
+    clone(): ODataEntityResource<T>;
     key(value: any): ODataEntityResource<T>;
     keys(values: any[]): ODataEntityResource<T>;
     media(): ODataMediaResource;

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

@@ -16,7 +16,11 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
         query?: ODataQueryOptions<R>;
     }): ODataFunctionResource<P, 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/resources/types/media.d.ts

@@ -9,6 +9,7 @@ export declare class ODataMediaResource extends ODataResource<any> {
         segments: ODataPathSegments;
         query?: ODataQueryOptions<V>;
     }): ODataMediaResource;
+    clone(): ODataMediaResource;
     protected get(options: {
         responseType: any;
     } & ODataOptions): Observable<any>;

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

@@ -7,6 +7,7 @@ import { ODataOptions } from './options';
 export declare class ODataMetadataResource extends ODataResource<any> {
     constructor(api: ODataApi, segments?: ODataPathSegments);
     static factory(api: ODataApi): ODataMetadataResource;
+    clone(): ODataMetadataResource;
     protected get(options?: ODataOptions): Observable<ODataMetadata>;
     fetch(options?: ODataOptions): Observable<ODataMetadata>;
 }

package/lib/resources/types/navigation-property.d.ts

@@ -26,6 +26,7 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
         query?: ODataQueryOptions<N>;
     }): ODataNavigationPropertyResource<N>;
     static fromResource<N>(resource: ODataResource<any>, path: string): ODataNavigationPropertyResource<N>;
+    clone(): ODataNavigationPropertyResource<T>;
     key(value: any): ODataNavigationPropertyResource<T>;
     keys(values: any[]): ODataNavigationPropertyResource<T>;
     media(): ODataMediaResource;

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

@@ -17,6 +17,7 @@ export declare class ODataPropertyResource<T> extends ODataResource<T> {
         query?: ODataQueryOptions<P>;
     }): ODataPropertyResource<P>;
     static fromResource<N>(resource: ODataResource<any>, path: string): ODataPropertyResource<N>;
+    clone(): ODataPropertyResource<T>;
     key(value: any): ODataPropertyResource<T>;
     keys(values: any[]): ODataPropertyResource<T>;
     value(): ODataValueResource<T>;

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

@@ -12,6 +12,7 @@ export declare class ODataReferenceResource<T> extends ODataResource<T> {
         segments: ODataPathSegments;
         query?: ODataQueryOptions<P>;
     }): ODataReferenceResource<P>;
+    clone(): ODataReferenceResource<T>;
     protected post(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
     protected put(target: ODataEntityResource<any>, options?: ODataOptions & {
         etag?: string;

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

@@ -17,6 +17,7 @@ export declare class ODataSingletonResource<T> extends ODataResource<T> {
         schema?: ODataStructuredType<S>;
         query?: ODataQueryOptions<S>;
     }): ODataSingletonResource<S>;
+    clone(): ODataSingletonResource<T>;
     key(value: any): ODataSingletonResource<T>;
     keys(values: any[]): ODataSingletonResource<T>;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;

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

@@ -12,6 +12,7 @@ export declare class ODataValueResource<T> extends ODataResource<T> {
         segments: ODataPathSegments;
         query?: ODataQueryOptions<V>;
     }): ODataValueResource<V>;
+    clone(): ODataValueResource<T>;
     protected get(options?: ODataOptions): Observable<T>;
     /**
      * Fetch the value of the resource.

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/element.d.ts

@@ -31,9 +31,15 @@ export declare class ODataSchemaElement extends ODataAnnotatable {
      */
     isTypeOf(type: string): boolean;
     /**
-     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * Returns a boolean indicating if the structured type is a subtype of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
     isSubtypeOf(schema: ODataSchemaElement): boolean;
+    /**
+     * Returns a boolean indicating if the structured type is a supertype of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSupertypeOf(schema: ODataSchemaElement): boolean;
 }

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';
@@ -28,6 +28,12 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * @returns The field with the given value
      */
     findFieldByValue(value: number): ODataEnumTypeFieldParser | undefined;
+    /**
+     * Find a fields by flag.
+     * @param value The value of the field
+     * @returns The fields with the given flag
+     */
+    findFieldsByValue(value: number): ODataEnumTypeFieldParser[];
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value
@@ -40,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';
@@ -18,11 +18,17 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
         findOptionsForType: (type: string) => any;
     }): void;
     /**
-     * Returns a boolean indicating if the structured type is a sub type of the given type.
+     * Returns a boolean indicating if the structured type is a subtype of the given type.
      * @param type String representation of the type
      * @returns True if the callable is type of the given type
      */
     isSubtypeOf(schema: ODataStructuredType<any>): boolean;
+    /**
+     * Returns a boolean indicating if the structured type is a supertype of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isSupertypeOf(schema: ODataStructuredType<any>): boolean;
     /**
      * Returns a boolean indicating if the structured type has a simple key.
      * @returns True if the structured type has a simple key
@@ -90,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

@@ -30,13 +30,11 @@ export declare enum QueryOptionNames {
     skip = "skip",
     skiptoken = "skiptoken",
     format = "format",
+    levels = "levels",
     count = "count"
 }
-export interface Options {
+export interface ApiOptions {
     version?: ODataVersion;
-    stringAsEnum?: boolean;
-}
-export interface ApiOptions extends Options {
     params?: {
         [param: string]: string | string[];
     };
@@ -63,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.0",
+  "version": "0.100.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {