angular-odata 0.90.0 → 0.99.2

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

@@ -1,31 +1,28 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
+import { ODataApi } from '../../api';
 import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity } from '../responses';
+import { ODataStructuredType } from '../../schema/structured-type';
 import { QueryOptionNames } from '../../types';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity } from '../responses';
 import { ODataActionResource } from './action';
-import { ODataApi } from '../../api';
 import { ODataCountResource } from './count';
 import { ODataEntityResource } from './entity';
 import { ODataFunctionResource } from './function';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path';
-import { ODataQueryOptions } from '../query';
 export declare class ODataEntitySetResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, query: ODataQueryOptions<E>): ODataEntitySetResource<E>;
+    static factory<E>(api: ODataApi, { path, schema, query, }: {
+        path: string;
+        schema?: ODataStructuredType<E>;
+        query?: ODataQueryOptions<E>;
+    }): ODataEntitySetResource<E>;
     clone(): ODataEntitySetResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     entity(key?: any): ODataEntityResource<T>;
-    cast<C>(type: string): ODataEntitySetResource<C>;
     action<P, R>(path: string): ODataActionResource<P, R>;
     function<P, R>(path: string): ODataFunctionResource<P, R>;
     count(): ODataCountResource<T>;
+    cast<C>(type: string): ODataEntitySetResource<C>;
     protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
     protected get(options?: ODataOptions & {
         withCount?: boolean;

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

@@ -1,30 +1,28 @@
-import { ODataResource } from '../resource';
-import { ODataEntity, ODataEntityAnnotations } from '../responses';
 import { Observable } from 'rxjs';
+import { ODataApi } from '../../api';
+import { ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema/structured-type';
 import { QueryOptionNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntity } from '../responses/types';
 import { ODataActionResource } from './action';
-import { ODataApi } from '../../api';
 import { ODataFunctionResource } from './function';
 import { ODataMediaResource } from './media';
-import { ODataModel } from '../../models';
 import { ODataNavigationPropertyResource } from './navigation-property';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query';
 export declare class ODataEntityResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions<E>): ODataEntityResource<E>;
+    static factory<E>(api: ODataApi, { schema, segments, query, }: {
+        schema?: ODataStructuredType<E>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<E>;
+    }): ODataEntityResource<E>;
     clone(): ODataEntityResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
     key(value: any): ODataEntityResource<T>;
     keys(values: any[]): ODataEntityResource<T>;
-    media(): ODataMediaResource<T>;
+    media(): ODataMediaResource;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
     property<P>(path: string): ODataPropertyResource<P>;
     action<P, R>(path: string): ODataActionResource<P, R>;

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

@@ -1,29 +1,23 @@
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
 import { ODataCollection } from '../../models/collection';
 import { ODataModel } from '../../models/model';
+import { ODataCallable } from '../../schema/callable';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
-    static factory<P, R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<R>): ODataFunctionResource<P, R>;
+    static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
+        path?: string;
+        schema?: ODataCallable<R>;
+        segments?: ODataPathSegments;
+        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;
-    schema(): import("angular-odata").ODataCallable<R> | undefined;
-    asModel<M extends ODataModel<R>>(entity: Partial<R> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(entities: Partial<R>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     parameters(params: P | null, { alias }?: {
         alias?: boolean;
     }): ODataFunctionResource<P, R>;

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

@@ -1,13 +1,15 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
-export declare class ODataMediaResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions<V>): ODataMediaResource<V>;
-    clone(): ODataMediaResource<T>;
-    schema(): undefined;
+import { ODataOptions } from './options';
+export declare class ODataMediaResource extends ODataResource<any> {
+    static factory<V>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<V>;
+    }): ODataMediaResource;
+    clone(): ODataMediaResource;
     protected get(options: {
         responseType: any;
     } & ODataOptions): Observable<any>;

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

@@ -1,14 +1,13 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataMetadata } from '../responses';
-import { ODataOptions } from './options';
 import { ODataPathSegments } from '../path';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataMetadata } from '../responses';
+import { ODataOptions } from './options';
 export declare class ODataMetadataResource extends ODataResource<any> {
     constructor(api: ODataApi, segments?: ODataPathSegments);
     static factory(api: ODataApi): ODataMetadataResource;
     clone(): ODataMetadataResource;
-    schema(): undefined;
     protected get(options?: ODataOptions): Observable<ODataMetadata>;
     fetch(options?: ODataOptions): Observable<ODataMetadata>;
 }

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

@@ -1,15 +1,16 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
+import { ODataApi } from '../../api';
 import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
+import { ODataStructuredType } from '../../schema';
 import { QueryOptionNames } from '../../types';
-import { ODataApi } from '../../api';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity } from '../responses';
 import { ODataCountResource } from './count';
 import { ODataMediaResource } from './media';
-import { ODataPathSegments } from '../path';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query';
 import { ODataReferenceResource } from './reference';
 /**
  * OData Navigation Property Resource
@@ -17,25 +18,19 @@ import { ODataReferenceResource } from './reference';
  * https://www.odata.org/getting-started/advanced-tutorial/#derived
  */
 export declare class ODataNavigationPropertyResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<E>): ODataNavigationPropertyResource<E>;
+    static factory<N>(api: ODataApi, { path, type, schema, segments, query, }: {
+        path: string;
+        type?: string;
+        schema?: ODataStructuredType<N>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<N>;
+    }): ODataNavigationPropertyResource<N>;
+    static fromResource<N>(resource: ODataResource<any>, path: string): ODataNavigationPropertyResource<N>;
     clone(): ODataNavigationPropertyResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     key(value: any): ODataNavigationPropertyResource<T>;
     keys(values: any[]): ODataNavigationPropertyResource<T>;
-    media(): ODataMediaResource<T>;
-    reference(): ODataReferenceResource;
+    media(): ODataMediaResource;
+    reference(): ODataReferenceResource<T>;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
     property<P>(path: string): ODataPropertyResource<P>;
     count(): ODataCountResource<T>;

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

@@ -1,28 +1,23 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
-import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 import { ODataApi } from '../../api';
+import { ODataCollection, ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 import { ODataValueResource } from './value';
 export declare class ODataPropertyResource<T> extends ODataResource<T> {
-    static factory<P>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<P>): ODataPropertyResource<P>;
+    static factory<P>(api: ODataApi, { path, type, schema, segments, query, }: {
+        path: string;
+        type?: string;
+        schema?: ODataStructuredType<P>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<P>;
+    }): ODataPropertyResource<P>;
+    static fromResource<N>(resource: ODataResource<any>, path: string): ODataPropertyResource<N>;
     clone(): ODataPropertyResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     key(value: any): ODataPropertyResource<T>;
     keys(values: any[]): ODataPropertyResource<T>;
     value(): ODataValueResource<T>;

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

@@ -1,14 +1,18 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataEntityResource } from './entity';
-import { ODataOptions } from './options';
+import { QueryOptionNames } from '../../types';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
-export declare class ODataReferenceResource extends ODataResource<any> {
-    static factory<P>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions<P>): ODataReferenceResource;
-    clone(): ODataReferenceResource;
-    schema(): undefined;
+import { ODataEntities, ODataEntity } from '../responses/types';
+import { ODataEntityResource } from './entity';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
+export declare class ODataReferenceResource<T> extends ODataResource<T> {
+    static factory<P>(api: ODataApi, { segments, query, }: {
+        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;
@@ -48,4 +52,34 @@ export declare class ODataReferenceResource extends ODataResource<any> {
     unset(options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
+    /**
+     * Fetch entity / entities
+     * @param options Options for the request
+     * @return An observable of the entity or entities with annotations
+     */
+    fetch(options?: ODataEntityOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<ODataEntity<T>>;
+    fetch(options?: ODataEntitiesOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<ODataEntities<T>>;
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
+    fetchEntity(options?: ODataOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<T | null>;
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options?: ODataOptions & {
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<T[] | null>;
 }

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

@@ -1,26 +1,23 @@
-import { ODataResource } from '../resource';
-import { ODataEntity, ODataEntityAnnotations } from '../responses';
+import { Observable } from 'rxjs';
+import { ODataApi } from '../../api';
+import { ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema';
 import { QueryOptionNames } from '../../types';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntity } from '../responses';
 import { ODataActionResource } from './action';
-import { ODataApi } from '../../api';
 import { ODataFunctionResource } from './function';
-import { ODataModel } from '../../models';
 import { ODataNavigationPropertyResource } from './navigation-property';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query';
-import { Observable } from 'rxjs';
 export declare class ODataSingletonResource<T> extends ODataResource<T> {
-    static factory<R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<R>): ODataSingletonResource<R>;
+    static factory<S>(api: ODataApi, { path, schema, query, }: {
+        path: string;
+        schema?: ODataStructuredType<S>;
+        query?: ODataQueryOptions<S>;
+    }): ODataSingletonResource<S>;
     clone(): ODataSingletonResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
     key(value: any): ODataSingletonResource<T>;
     keys(values: any[]): ODataSingletonResource<T>;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;

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

@@ -1,13 +1,18 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
+import { ODataStructuredType } from '../../schema/structured-type';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataOptions } from './options';
 export declare class ODataValueResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<V>): ODataValueResource<V>;
+    static factory<V>(api: ODataApi, { type, schema, segments, query, }: {
+        type?: string;
+        schema?: ODataStructuredType<V>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<V>;
+    }): ODataValueResource<V>;
     clone(): ODataValueResource<T>;
-    schema(): undefined;
     protected get(options?: ODataOptions): Observable<T>;
     /**
      * Fetch the value of the resource.

package/lib/schema/annotation.d.ts

@@ -8,3 +8,21 @@ export declare class ODataAnnotation {
     properties?: string[];
     constructor(annot: AnnotationConfig);
 }
+export declare class ODataAnnotatable {
+    annotations: ODataAnnotation[];
+    constructor(config: {
+        annotations?: AnnotationConfig[];
+    });
+    /**
+     * Find an annotation inside the annotatable.
+     * @param predicate Function that returns true if the annotation match.
+     * @returns The annotation that matches the predicate.
+     */
+    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
+    /**
+     * Find an annotation inside the annotatable and return its value.
+     * @param term The term of the annotation to find.
+     * @returns The value of the annotation.
+     */
+    annotatedValue<T>(term: string | RegExp): T | undefined;
+}

package/lib/schema/callable.d.ts

@@ -1,30 +1,14 @@
 import { CallableConfig, Options, Parser } from '../types';
-import { ODataCallableParser } from '../parsers';
+import { ODataSchemaElement } from './element';
+import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataCallable<R> {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataCallable<R> extends ODataSchemaElement {
     entitySetPath?: string;
     bound?: boolean;
     composable?: boolean;
     parser: ODataCallableParser<R>;
     constructor(config: CallableConfig, schema: ODataSchema);
     path(): string;
-    /**
-     * Returns a full type of the callable including the namespace/alias.
-     * @param alias Use the alias of the namespace instead of the namespace.
-     * @returns The string representation of the type.
-     */
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
-    /**
-     * Returns a boolean indicating if the callable is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(type: string): boolean;
-    get api(): import("angular-odata").ODataApi;
     configure({ parserForType, }: {
         parserForType: (type: string) => Parser<any>;
     }): void;
@@ -53,5 +37,5 @@ export declare class ODataCallable<R> {
      * Returns the binding parameter of the callable.
      * @returns The binding parameter of the callable.
      */
-    binding(): import("../parsers").ODataParameterParser<any> | undefined;
+    binding(): import("./parsers").ODataParameterParser<any> | undefined;
 }

package/lib/schema/element.d.ts

@@ -0,0 +1,45 @@
+import { AnnotationConfig } from '../types';
+import { ODataAnnotatable } from './annotation';
+import { ODataSchema } from './schema';
+export declare class ODataSchemaElement extends ODataAnnotatable {
+    name: string;
+    schema: ODataSchema;
+    constructor(config: {
+        annotations?: AnnotationConfig[];
+        name: string;
+    }, schema: ODataSchema);
+    get api(): import("angular-odata").ODataApi;
+    /**
+     * 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.
+     */
+    titleize(term?: string | RegExp): string;
+    /**
+     * Returns a full type of the structured type including the namespace/alias.
+     * @param alias Use the alias of the namespace instead of the namespace.
+     * @returns The string representation of the type.
+     */
+    type({ alias }?: {
+        alias?: boolean;
+    }): string;
+    /**
+     * Returns a boolean indicating if the structured type is of the given type.
+     * @param type String representation of the type
+     * @returns True if the callable is type of the given type
+     */
+    isTypeOf(type: string): boolean;
+    /**
+     * 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/entity-container.d.ts

@@ -1,18 +1,8 @@
 import { EntityContainerConfig } from '../types';
-import { ODataAnnotation } from './annotation';
+import { ODataSchemaElement } from './element';
 import { ODataEntitySet } from './entity-set';
 import { ODataSchema } from './schema';
-export declare class ODataEntityContainer {
-    schema: ODataSchema;
-    name: string;
-    annotations: ODataAnnotation[];
+export declare class ODataEntityContainer extends ODataSchemaElement {
     entitySets: ODataEntitySet[];
     constructor(config: EntityContainerConfig, schema: ODataSchema);
-    get api(): import("angular-odata").ODataApi;
-    /**
-     * Find an annotation inside the entity container.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
 }

package/lib/schema/entity-set.d.ts

@@ -1,26 +1,10 @@
 import { EntitySetConfig } from '../types';
-import { ODataAnnotation } from './annotation';
+import { ODataSchemaElement } from './element';
 import { ODataSchema } from './schema';
-export declare class ODataEntitySet {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataEntitySet extends ODataSchemaElement {
     entityType: string;
     service: {
         new (...params: any[]): any;
     };
-    annotations: ODataAnnotation[];
     constructor(config: EntitySetConfig, schema: ODataSchema);
-    /**
-     * Returns a boolean indicating if the entity set is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(type: string): boolean;
-    get api(): import("angular-odata").ODataApi;
-    /**
-     * Find an annotation inside the entity set.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
 }

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

@@ -1,40 +1,16 @@
 import { EnumTypeConfig, Options } from '../types';
-import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from '../parsers';
-import { ODataAnnotation } from './annotation';
+import { ODataSchemaElement } from './element';
+import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
-export declare class ODataEnumType<E> {
-    schema: ODataSchema;
-    name: string;
+export declare class ODataEnumType<E> extends ODataSchemaElement {
     parser: ODataEnumTypeParser<E>;
     members: {
         [name: string]: number;
     } | {
         [value: number]: string;
     };
-    annotations: ODataAnnotation[];
     constructor(config: EnumTypeConfig<E>, schema: ODataSchema);
-    /**
-     * Returns a full type of the enum type including the namespace/alias.
-     * @param alias Use the alias of the namespace instead of the namespace.
-     * @returns The string representation of the type.
-     */
-    type({ alias }?: {
-        alias?: boolean;
-    }): string;
-    /**
-     * Returns a boolean indicating if the enum type is of the given type.
-     * @param type String representation of the type
-     * @returns True if the callable is type of the given type
-     */
-    isTypeOf(type: string): boolean;
-    get api(): import("angular-odata").ODataApi;
     configure(): void;
-    /**
-     * Find an annotation inside the enum type.
-     * @param predicate Function that returns true if the annotation match.
-     * @returns The annotation that matches the predicate.
-     */
-    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
     /**
      * Returns the fields of the enum type.
      * @returns The fields of the enum type.
@@ -52,13 +28,6 @@ export declare class ODataEnumType<E> {
      * @returns The field with the given value
      */
     findFieldByValue(value: number): ODataEnumTypeFieldParser | undefined;
-    /**
-     * Find a title for a given value.
-     * @param value Value of the field
-     * @param pattern Pattern to use for find in annotations
-     * @returns The name or annotation of the filed that matches with the value.
-     */
-    fieldTitle(value: number | string, pattern?: RegExp): string;
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value

package/lib/schema/index.d.ts

@@ -4,3 +4,4 @@ export * from './callable';
 export * from './enum-type';
 export * from './structured-type';
 export * from './entity-set';
+export * from './parsers';

package/lib/{parsers → schema/parsers}/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, Options, OptionsHelper, Parameter, Parser } from '../types';
+import { CallableConfig, Options, OptionsHelper, Parameter, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {

package/lib/{parsers → schema/parsers}/edm.d.ts

@@ -1,4 +1,4 @@
-import { Parser } from '../types';
+import { Parser } from '../../types';
 export declare const EDM_PARSERS: {
     [type: string]: Parser<any>;
 };