angular-odata 0.128.0 → 0.131.0

package/lib/api.d.ts

@@ -1,11 +1,10 @@
 import { Observable } from 'rxjs';
-import { ODataCache } from './cache';
 import { ModelOptions, ODataCollection, ODataModel, ODataModelOptions } from './models';
 import { ODataApiOptions } from './options';
 import { ODataOptions, ODataResource, ODataSegment } from './resources';
 import { ODataRequest, ODataBatchResource, ODataMetadataResource, ODataActionResource, ODataFunctionResource, ODataEntityResource, ODataEntitySetResource, ODataSingletonResource, ODataNavigationPropertyResource } from './resources';
 import { ODataCallable, ODataEntitySet, ODataEnumType, ODataSchema, ODataSingleton, ODataStructuredType } from './schema';
-import { ApiConfig, EdmType, ODataVersion, Parser, QueryOption, SchemaConfig } from './types';
+import { ODataApiConfig, EdmType, ODataVersion, Parser, QueryOption, ODataSchemaConfig, ODataCache } from './types';
 import { ODataMetadata } from './metadata/metadata';
 /**
  * Api abstraction for consuming OData services.
@@ -19,11 +18,11 @@ export declare class ODataApi {
     default: boolean;
     creation: Date;
     options: ODataApiOptions;
-    cache: ODataCache;
+    cache?: ODataCache;
     errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
     parsers: Map<string, Parser<any>>;
     schemas: ODataSchema[];
-    constructor(config: ApiConfig);
+    constructor(config: ODataApiConfig);
     configure(settings?: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;
@@ -74,9 +73,9 @@ export declare class ODataApi {
      * @returns ODataFunctionResource
      */
     function<P, R>(path: string): ODataFunctionResource<P, R>;
-    callable<T>(type: string): ODataCallable<T> | undefined;
-    enumType<T>(type: string): ODataEnumType<T> | undefined;
-    structuredType<T>(type: string): ODataStructuredType<T> | undefined;
+    callable<T>(type: string): ODataCallable<any> | undefined;
+    enumType<T>(type: string): ODataEnumType<any> | undefined;
+    structuredType<T>(type: string): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
     request<T>(method: string, resource: ODataResource<any>, options: ODataOptions & {
         body?: any;
         etag?: string;
@@ -86,11 +85,11 @@ export declare class ODataApi {
         bodyQueryOptions?: QueryOption[];
     }): Observable<any>;
     private memo;
-    createSchema(config: SchemaConfig): ODataSchema;
+    createSchema(config: ODataSchemaConfig): ODataSchema;
     findSchema(type: string): ODataSchema | undefined;
-    findEnumType<T>(value: string): ODataEnumType<T> | undefined;
-    findStructuredType<T>(value: string): ODataStructuredType<T> | undefined;
-    findCallable<R>(value: string, bindingType?: string): ODataCallable<R> | undefined;
+    findEnumType<T>(value: string): ODataEnumType<any> | undefined;
+    findStructuredType<T>(value: string): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
+    findCallable<R>(value: string, bindingType?: string): ODataCallable<any> | undefined;
     findEntitySet(value: string): ODataEntitySet | undefined;
     findSingleton(value: string): ODataSingleton | undefined;
     findModel(type: string): typeof ODataModel | undefined;

package/lib/cache/cache.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { ODataRequest, ODataResponse } from '../resources';
-import { Cache } from '../types';
+import { ODataCache } from '../types';
 /**
  * A cache entry that holds a payload, a last read time, and a timeout for the entry.
  * @param payload The payload to cache.
@@ -14,7 +14,7 @@ export interface ODataCacheEntry<T> {
     timeout: number;
     tags: string[];
 }
-export declare abstract class ODataCache implements Cache {
+export declare abstract class ODataBaseCache implements ODataCache {
     timeout: number;
     entries: Map<string, ODataCacheEntry<any>>;
     constructor({ timeout }: {

package/lib/cache/memory.d.ts

@@ -1,6 +1,6 @@
 import { ODataRequest, ODataResponse } from '../resources';
-import { ODataCache } from './cache';
-export declare class ODataInMemoryCache extends ODataCache {
+import { ODataBaseCache } from './cache';
+export declare class ODataInMemoryCache extends ODataBaseCache {
     constructor({ timeout }?: {
         timeout?: number;
     });

package/lib/cache/storage.d.ts

@@ -1,6 +1,6 @@
 import { ODataRequest, ODataResponse } from '../resources';
-import { ODataCache } from './cache';
-export declare class ODataInStorageCache extends ODataCache {
+import { ODataBaseCache } from './cache';
+export declare class ODataInStorageCache extends ODataBaseCache {
     name: string;
     storage: Storage;
     constructor({ name, storage, timeout, }: {

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 export * from './types';
 export * from './settings';
+export * from './annotations';
 export * from './api';
 export * from './client';
 export * from './module';

package/lib/loaders.d.ts

@@ -1,21 +1,21 @@
 import { Observable } from 'rxjs';
-import { ApiConfig } from './types';
+import { ODataApiConfig } from './types';
 export declare abstract class ODataConfigLoader {
-    abstract loadConfigs(): Observable<ApiConfig[]>;
+    abstract loadConfigs(): Observable<ODataApiConfig[]>;
 }
 export declare class ODataConfigSyncLoader implements ODataConfigLoader {
     private readonly passedConfigs;
-    constructor(passedConfigs: ApiConfig | ApiConfig[]);
-    loadConfigs(): Observable<ApiConfig[]>;
+    constructor(passedConfigs: ODataApiConfig | ODataApiConfig[]);
+    loadConfigs(): Observable<ODataApiConfig[]>;
 }
 export declare class ODataConfigAsyncLoader implements ODataConfigLoader {
     private readonly configs$;
-    constructor(configs$: Observable<ApiConfig>[] | Observable<ApiConfig | ApiConfig[]>);
-    loadConfigs(): Observable<ApiConfig[]>;
+    constructor(configs$: Observable<ODataApiConfig>[] | Observable<ODataApiConfig | ODataApiConfig[]>);
+    loadConfigs(): Observable<ODataApiConfig[]>;
 }
 export declare class ODataMetadataLoader implements ODataConfigLoader {
     private readonly sources$;
     private readonly baseConfigs;
-    constructor(sources$: Observable<string | string[]>, baseConfigs: ApiConfig | ApiConfig[]);
-    loadConfigs(): Observable<ApiConfig[]>;
+    constructor(sources$: Observable<string | string[]>, baseConfigs: ODataApiConfig | ODataApiConfig[]);
+    loadConfigs(): Observable<ODataApiConfig[]>;
 }

package/lib/metadata/csdl/csdl-annotation.d.ts

@@ -1,10 +1,16 @@
-import { AnnotationConfig } from '../../types';
+import { ODataAnnotationConfig } from '../../types';
 import type { CsdlSchema } from './csdl-schema';
 export declare class CsdlAnnotable {
     Annotation?: CsdlAnnotation[];
     constructor({ Annotation }: {
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): {
+        [key: string]: any;
+    };
 }
 export declare class CsdlAnnotations extends CsdlAnnotable {
     private schema;
@@ -13,28 +19,34 @@ export declare class CsdlAnnotations extends CsdlAnnotable {
     constructor(schema: CsdlSchema, { Target, Qualifier, Annotation, }: {
         Target: string;
         Qualifier?: string;
-        Annotation: CsdlAnnotation[];
+        Annotation: any[];
     });
-    toConfig(): AnnotationConfig[];
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): ODataAnnotationConfig[];
 }
 export declare class CsdlAnnotation {
     Term: string;
     String?: string;
     Bool?: boolean;
     Int?: number;
-    Collection?: any;
-    Record?: any;
-    Members?: any;
-    constructor({ Term, String, Bool, Int, Collection, Record, Members, }: {
+    Collection?: CsdlCollection[];
+    Record?: CsdlRecord[];
+    EnumMember?: CsdlEnumMember[];
+    constructor({ Term, String, Bool, Int, Collection, Record, EnumMember, }: {
         Term: string;
         String?: string;
         Bool?: boolean;
         Int?: number;
-        Collection?: any;
-        Record?: any;
-        Members?: any;
+        Collection?: any[];
+        Record?: any[];
+        EnumMember?: any[];
     });
-    toConfig(): AnnotationConfig;
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): ODataAnnotationConfig;
 }
 export declare class CsdlTerm {
     private schema;
@@ -66,58 +78,82 @@ export declare class CsdlTerm {
         Bool?: boolean;
         Int?: number;
     });
+    toJson(): {
+        [key: string]: any;
+    };
 }
 export declare class CsdlCollection {
-    Strings: CsdlString[];
-    Records: CsdlRecord[];
-    PropertyPaths: CsdlPropertyPath[];
-    NavigationPropertyPaths: CsdlNavigationPropertyPath[];
-    constructor({ Strings, Records, PropertyPaths, NavigationPropertyPaths, }: {
-        Strings: CsdlString[];
-        Records: CsdlRecord[];
-        PropertyPaths: CsdlPropertyPath[];
-        NavigationPropertyPaths: CsdlNavigationPropertyPath[];
+    String: CsdlString[];
+    Record: CsdlRecord[];
+    PropertyPath: CsdlPropertyPath[];
+    NavigationPropertyPath: CsdlNavigationPropertyPath[];
+    constructor({ String, Record, PropertyPath, NavigationPropertyPath, }: {
+        String: any[];
+        Record: any[];
+        PropertyPath: any[];
+        NavigationPropertyPath: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
 }
 export declare class CsdlRecord {
-    Properties: CsdlPropertyValue[];
-    constructor({ Properties }: {
-        Properties: CsdlPropertyValue[];
+    PropertyValue: CsdlPropertyValue[];
+    constructor({ PropertyValue }: {
+        PropertyValue: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
 }
 export declare class CsdlPropertyValue {
     Name: string;
     String?: string;
     Date?: Date;
-    Members?: CsdlEnumMember[];
-    constructor({ Name, String, Date, Members, }: {
+    EnumMember?: CsdlEnumMember[];
+    constructor({ Name, String, Date, EnumMember, }: {
         Name: string;
         String?: string;
         Date?: Date;
-        Members?: CsdlEnumMember[];
+        EnumMember?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
 }
 export declare class CsdlEnumMember {
     TextContent: string;
     constructor({ TextContent }: {
         TextContent: string;
     });
+    toJson(): {
+        TextContent: string;
+    };
 }
 export declare class CsdlString {
     TextContent: string;
     constructor({ TextContent }: {
         TextContent: string;
     });
+    toJson(): {
+        TextContent: string;
+    };
 }
 export declare class CsdlPropertyPath {
     TextContent: string;
     constructor({ TextContent }: {
         TextContent: string;
     });
+    toJson(): {
+        TextContent: string;
+    };
 }
 export declare class CsdlNavigationPropertyPath {
     TextContent: string;
     constructor({ TextContent }: {
         TextContent: string;
     });
+    toJson(): {
+        TextContent: string;
+    };
 }

package/lib/metadata/csdl/csdl-entity-container.d.ts

@@ -3,7 +3,7 @@ import { CsdlSingleton } from './csdl-singleton';
 import { CsdlFunctionImport, CsdlActionImport } from './csdl-function-action';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlSchema } from './csdl-schema';
-import { EntityContainerConfig } from '../../types';
+import { ODataEntityContainerConfig } from '../../types';
 export declare class CsdlEntityContainer extends CsdlAnnotable {
     private schema;
     Name: string;
@@ -21,6 +21,11 @@ export declare class CsdlEntityContainer extends CsdlAnnotable {
         ActionImport?: any[];
         Annotation?: any[];
     });
-    get Namespace(): string;
-    toConfig(): EntityContainerConfig;
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
+    fullName(): string;
+    toConfig(base?: Partial<ODataEntityContainerConfig>): ODataEntityContainerConfig;
 }

package/lib/metadata/csdl/csdl-entity-set.d.ts

@@ -1,4 +1,4 @@
-import { EntitySetConfig } from '../../types';
+import { ODataEntitySetConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlEntityContainer } from './csdl-entity-container';
 import { CsdlNavigationPropertyBinding } from './csdl-navigation-property-binding';
@@ -15,6 +15,11 @@ export declare class CsdlEntitySet extends CsdlAnnotable {
         IncludeInServiceDocument?: boolean;
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
     fullName(): string;
-    toConfig(): EntitySetConfig;
+    toConfig(): ODataEntitySetConfig;
 }

package/lib/metadata/csdl/csdl-enum-type.d.ts

@@ -1,4 +1,4 @@
-import { EnumTypeConfig, EnumTypeFieldConfig } from '../../types';
+import { ODataEnumTypeConfig, ODataEnumTypeFieldConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlSchema } from './csdl-schema';
 export declare class CsdlEnumType extends CsdlAnnotable {
@@ -14,8 +14,13 @@ export declare class CsdlEnumType extends CsdlAnnotable {
         IsFlags?: boolean;
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
     fullName(): string;
-    toConfig(): EnumTypeConfig<any>;
+    toConfig(base?: Partial<ODataEnumTypeConfig>): ODataEnumTypeConfig;
 }
 export declare class CsdlMember extends CsdlAnnotable {
     Name: string;
@@ -25,5 +30,8 @@ export declare class CsdlMember extends CsdlAnnotable {
         Value?: number;
         Annotation?: any[];
     });
-    toConfig(): EnumTypeFieldConfig<any>;
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(base?: Partial<ODataEnumTypeFieldConfig>): ODataEnumTypeFieldConfig;
 }

package/lib/metadata/csdl/csdl-function-action.d.ts

@@ -1,43 +1,56 @@
-import { CallableConfig, ParameterConfig } from '../../types';
+import { ODataCallableConfig, ODataParameterConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import type { CsdlEntityContainer } from './csdl-entity-container';
 import type { CsdlSchema } from './csdl-schema';
+export declare const BINDING_PARAMETER_NAME: string;
 export declare class CsdlCallable {
     private schema;
     Name: string;
     ReturnType?: CsdlReturnType;
     IsBound?: boolean;
     EntitySetPath?: string;
-    Parameters?: CsdlParameter[];
-    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameters, }: {
+    Parameter?: CsdlParameter[];
+    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
         Name: string;
         ReturnType?: any;
         IsBound?: boolean;
         EntitySetPath?: string;
-        Parameters?: any[];
+        Parameter?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
+    fullName(): string;
 }
 export declare class CsdlFunction extends CsdlCallable {
     IsComposable?: boolean;
-    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, IsComposable, Parameters, }: {
+    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, IsComposable, Parameter, }: {
         Name: string;
         ReturnType: any;
         IsBound?: boolean;
         EntitySetPath?: string;
         IsComposable?: boolean;
-        Parameters?: any[];
+        Parameter?: any[];
     });
-    toConfig(): CallableConfig;
+    toJson(): {
+        IsComposable: boolean | undefined;
+    };
+    toConfig(base?: Partial<ODataCallableConfig>): ODataCallableConfig;
 }
 export declare class CsdlAction extends CsdlCallable {
-    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameters, }: {
+    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
         Name: string;
         ReturnType?: any;
         IsBound?: boolean;
         EntitySetPath?: string;
-        Parameters?: any[];
+        Parameter?: any[];
     });
-    toConfig(): CallableConfig;
+    toJson(): {
+        [x: string]: any;
+    };
+    toConfig(base?: Partial<ODataCallableConfig>): ODataCallableConfig;
 }
 export declare class CsdlFunctionImport {
     private container;
@@ -51,6 +64,12 @@ export declare class CsdlFunctionImport {
         EntitySet?: string;
         IncludeInServiceDocument?: boolean;
     });
+    toJson(): {
+        Name: string;
+        FunctionName: string;
+        EntitySet: string | undefined;
+        IncludeInServiceDocument: boolean | undefined;
+    };
 }
 export declare class CsdlActionImport {
     private container;
@@ -62,10 +81,16 @@ export declare class CsdlActionImport {
         Action: string;
         EntitySet?: string;
     });
+    toJson(): {
+        Name: string;
+        Action: string;
+        EntitySet: string | undefined;
+    };
 }
 export declare class CsdlParameter extends CsdlAnnotable {
     Name: string;
     Type: string;
+    Collection: boolean;
     Nullable?: boolean;
     MaxLength?: number;
     Precision?: number;
@@ -81,10 +106,20 @@ export declare class CsdlParameter extends CsdlAnnotable {
         SRID?: string;
         Annotation?: any[];
     });
-    toConfig(): ParameterConfig;
+    toJson(): {
+        Name: string;
+        Type: string;
+        Nullable: boolean | undefined;
+        MaxLength: number | undefined;
+        Precision: number | undefined;
+        Scale: number | undefined;
+        SRID: string | undefined;
+    };
+    toConfig(): ODataParameterConfig;
 }
 export declare class CsdlReturnType {
     Type: string;
+    Collection: boolean;
     Nullable?: boolean;
     MaxLength?: number;
     Precision?: number;
@@ -98,6 +133,14 @@ export declare class CsdlReturnType {
         Scale?: number;
         SRID?: string;
     });
+    toJson(): {
+        Type: string;
+        Nullable: boolean | undefined;
+        MaxLength: number | undefined;
+        Precision: number | undefined;
+        Scale: number | undefined;
+        SRID: string | undefined;
+    };
     toConfig(): {
         type: string;
         collection?: boolean | undefined;

package/lib/metadata/csdl/csdl-navigation-property-binding.d.ts

@@ -5,4 +5,8 @@ export declare class CsdlNavigationPropertyBinding {
         Path: string;
         Target: string;
     });
+    toJson(): {
+        Path: string;
+        Target: string;
+    };
 }

package/lib/metadata/csdl/csdl-reference.d.ts

@@ -1,14 +1,19 @@
+import { ODataReferenceConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 export declare class CsdlReference extends CsdlAnnotable {
     Uri: string;
-    Includes?: CsdlInclude[];
+    Include?: CsdlInclude[];
     IncludeAnnotations?: CsdlIncludeAnnotations[];
-    constructor({ Uri, Includes, IncludeAnnotations, Annotation, }: {
+    constructor({ Uri, Include, IncludeAnnotations, Annotation, }: {
         Uri: string;
-        Includes?: any[];
+        Include?: any[];
         IncludeAnnotations?: any[];
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(base?: Partial<ODataReferenceConfig>): ODataReferenceConfig;
 }
 export declare class CsdlInclude {
     Namespace: string;
@@ -17,6 +22,14 @@ export declare class CsdlInclude {
         Namespace: string;
         Alias?: string;
     });
+    toJson(): {
+        Namespace: string;
+        Alias: string | undefined;
+    };
+    toConfig(): {
+        namespace: string;
+        alias: string | undefined;
+    };
 }
 export declare class CsdlIncludeAnnotations {
     TermNamespace: string;
@@ -27,4 +40,14 @@ export declare class CsdlIncludeAnnotations {
         Qualifier?: string;
         TargetNamespace?: string;
     });
+    toJson(): {
+        TermNamespace: string;
+        Qualifier: string | undefined;
+        TargetNamespace: string | undefined;
+    };
+    toConfig(): {
+        termNamespace: string;
+        qualifier: string | undefined;
+        targetNamespace: string | undefined;
+    };
 }

package/lib/metadata/csdl/csdl-schema.d.ts

@@ -4,7 +4,7 @@ import { CsdlEnumType } from './csdl-enum-type';
 import { CsdlEntityType, CsdlComplexType } from './csdl-structured-type';
 import { CsdlFunction, CsdlAction } from './csdl-function-action';
 import { CsdlEntityContainer } from './csdl-entity-container';
-import { SchemaConfig } from '../../types';
+import { ODataSchemaConfig } from '../../types';
 export declare class CsdlSchema {
     Namespace: string;
     Alias?: string;
@@ -30,5 +30,8 @@ export declare class CsdlSchema {
         Term?: any[];
         Annotations?: any[];
     });
-    toConfig(): SchemaConfig;
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(base?: Partial<ODataSchemaConfig>): ODataSchemaConfig;
 }

package/lib/metadata/csdl/csdl-singleton.d.ts

@@ -12,5 +12,10 @@ export declare class CsdlSingleton extends CsdlAnnotable {
         NavigationPropertyBindings?: any[];
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
     fullName(): string;
 }

package/lib/metadata/csdl/csdl-structural-property.d.ts

@@ -1,4 +1,4 @@
-import { StructuredTypeFieldConfig } from '../../types';
+import { ODataStructuredTypeFieldConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 export declare abstract class CsdlStructuralProperty extends CsdlAnnotable {
     Name: string;
@@ -11,6 +11,9 @@ export declare abstract class CsdlStructuralProperty extends CsdlAnnotable {
         Nullable?: boolean;
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
 }
 export declare class CsdlProperty extends CsdlStructuralProperty {
     MaxLength?: number;
@@ -31,7 +34,10 @@ export declare class CsdlProperty extends CsdlStructuralProperty {
         DefaultValue?: string;
         Annotation?: any[];
     });
-    toConfig(): StructuredTypeFieldConfig & {
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): ODataStructuredTypeFieldConfig & {
         name: string;
     };
 }
@@ -50,7 +56,10 @@ export declare class CsdlNavigationProperty extends CsdlStructuralProperty {
         OnDelete?: any;
         Annotation?: any[];
     });
-    toConfig(): StructuredTypeFieldConfig & {
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): ODataStructuredTypeFieldConfig & {
         name: string;
     };
 }
@@ -61,10 +70,17 @@ export declare class CsdlReferentialConstraint {
         Property: string;
         ReferencedProperty: string;
     });
+    toJson(): {
+        Property: string;
+        ReferencedProperty: string;
+    };
 }
 export declare class CsdlOnDelete {
     Action: string;
     constructor({ Action }: {
         Action: string;
     });
+    toJson(): {
+        Action: string;
+    };
 }