angular-odata 0.127.0 → 0.130.0

package/lib/{resources/responses/annotations.d.ts → annotations.d.ts}

@@ -1,5 +1,5 @@
-import { ODataContext, ODataVersionHelper } from '../../helper';
-import { ODataMetadataType } from '../../types';
+import { ODataContext, ODataVersionHelper } from './helper';
+import { ODataMetadataType } from './types';
 export declare abstract class ODataAnnotations<T> {
     helper: ODataVersionHelper;
     protected annotations: Map<string, any>;

package/lib/api.d.ts

@@ -1,11 +1,12 @@
 import { Observable } from 'rxjs';
-import { ODataCache } from './cache/index';
-import { ODataCollection, ODataModel, ODataModelOptions } from './models/index';
+import { ODataCache } from './cache';
+import { ModelOptions, ODataCollection, ODataModel, ODataModelOptions } from './models';
 import { ODataApiOptions } from './options';
-import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataOptions, ODataRequest, ODataResource, ODataSegment, ODataSingletonResource } from './resources/index';
-import { ODataCallable, ODataEntitySet, ODataEnumType, ODataSchema, ODataStructuredType } from './schema';
-import { ODataEntityService } from './services/entity';
-import { ApiConfig, EdmType, Parser, QueryOption } from './types';
+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 { ODataMetadata } from './metadata/metadata';
 /**
  * Api abstraction for consuming OData services.
  */
@@ -14,7 +15,7 @@ export declare class ODataApi {
     serviceRootUrl: string;
     metadataUrl: string;
     name?: string;
-    version: string;
+    version: ODataVersion;
     default: boolean;
     creation: Date;
     options: ODataApiOptions;
@@ -26,6 +27,7 @@ export declare class ODataApi {
     configure(settings?: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;
+    populate(metadata: ODataMetadata): void;
     fromJson<P, R>(json: {
         segments: ODataSegment[];
         options: {
@@ -53,13 +55,13 @@ export declare class ODataApi {
      * @param path Name of the singleton
      * @returns
      */
-    singleton<T>(path: string): ODataSingletonResource<T>;
+    singleton<T>(name: string): ODataSingletonResource<T>;
     /**
      * Build an entity set resource.
      * @param path Name of the entity set
      * @returns
      */
-    entitySet<T>(path: string): ODataEntitySetResource<T>;
+    entitySet<T>(name: string): ODataEntitySetResource<T>;
     /**
      * Unbound Action
      * @param  {string} path?
@@ -72,6 +74,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;
     request<T>(method: string, resource: ODataResource<any>, options: ODataOptions & {
         body?: any;
         etag?: string;
@@ -81,25 +86,23 @@ export declare class ODataApi {
         bodyQueryOptions?: QueryOption[];
     }): Observable<any>;
     private memo;
-    private findSchemaForType;
-    findEnumTypeForType<T>(type: string): ODataEnumType<T> | undefined;
-    findStructuredTypeForType<T>(type: string): ODataStructuredType<T> | undefined;
-    findCallableForType<T>(type: string, bindingType?: string): ODataCallable<T> | undefined;
-    findEntitySetForType(type: string): ODataEntitySet | undefined;
-    findModelForType(type: string): typeof ODataModel | undefined;
+    createSchema(config: SchemaConfig): 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;
+    findEntitySet(value: string): ODataEntitySet | undefined;
+    findSingleton(value: string): ODataSingleton | undefined;
+    findModel(type: string): typeof ODataModel | undefined;
+    createModel(structured: ODataStructuredType<any>): typeof ODataModel;
     modelForType(type: string): typeof ODataModel;
-    findCollectionForType(type: string): typeof ODataCollection | undefined;
+    findCollection(type: string): typeof ODataCollection | undefined;
+    createCollection(structured: ODataStructuredType<any>, model?: typeof ODataModel<any>): typeof ODataCollection;
     collectionForType(type: string): typeof ODataCollection;
-    findServiceForType(type: string): typeof ODataEntityService | undefined;
     findEntitySetForEntityType(entityType: string): ODataEntitySet | undefined;
-    findServiceForEntityType(entityType: string): typeof ODataEntityService | undefined;
-    findEnumTypeByName<T>(name: string): ODataEnumType<T> | undefined;
-    findStructuredTypeByName<T>(name: string): ODataStructuredType<T> | undefined;
-    findCallableByName<T>(name: string, bindingType?: string): ODataCallable<T> | undefined;
-    findEntitySetByName(name: string): ODataEntitySet | undefined;
-    findModelByName(name: string): typeof ODataModel | undefined;
-    findCollectionByName(name: string): typeof ODataCollection | undefined;
-    findServiceByName(name: string): typeof ODataEntityService | undefined;
     parserForType<T>(type: string | EdmType, bindingType?: string): Parser<T>;
-    findOptionsForType<T>(type: string): ODataModelOptions<any> | ODataModelOptions<T> | undefined;
+    optionsForType<T>(type: string, { structuredType, config, }?: {
+        structuredType?: ODataStructuredType<T>;
+        config?: ModelOptions;
+    }): ODataModelOptions<T> | undefined;
 }

package/lib/cache/memory.d.ts

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

package/lib/client.d.ts

@@ -4,7 +4,6 @@ import { ODataApi } from './api';
 import { ODataConfigLoader } from './loaders';
 import { ODataCollection, ODataModel } from './models/index';
 import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataOptions, ODataResource, ODataResponse, ODataSegment, ODataSingletonResource } from './resources/index';
-import { ODataEntityService } from './services/entity';
 import { ODataSettings } from './settings';
 import * as i0 from "@angular/core";
 export declare class ODataClient {
@@ -62,25 +61,6 @@ export declare class ODataClient {
      * @returns The collection for the given type.
      */
     collectionForType(type: string): typeof ODataCollection;
-    /**
-     * Resolve the service for the given string type.
-     * @param type The string type of the service.
-     * @returns The service for the given type.
-     */
-    serviceForType(type: string): ODataEntityService<any> | undefined;
-    /**
-     * Resolve the service for the given string entity type.
-     * @param type The string entity type binding to the service.
-     * @returns The service for the given entity type.
-     */
-    serviceForEntityType(type: string): ODataEntityService<any> | undefined;
-    enumTypeByName<T>(name: string): import("angular-odata").ODataEnumType<T>;
-    structuredTypeByName<T>(name: string): import("angular-odata").ODataStructuredType<T>;
-    callableByName<T>(name: string): import("angular-odata").ODataCallable<T>;
-    entitySetByName(name: string): import("angular-odata").ODataEntitySet;
-    modelByName(name: string): typeof ODataModel;
-    collectionByName(name: string): typeof ODataCollection;
-    serviceByName(name: string): ODataEntityService<any> | undefined;
     fromJson<E>(json: {
         segments: ODataSegment[];
         options: {

package/lib/constants.d.ts

@@ -29,7 +29,10 @@ export declare const RETRY_AFTER = "Retry-After";
 export declare const RETRY_AFTER_HEADERS: string[];
 export declare const APPLICATION_JSON = "application/json";
 export declare const APPLICATION_HTTP = "application/http";
+export declare const APPLICATION_XHTML = "application/xhtml+xml";
+export declare const APPLICATION_XML = "application/xml";
 export declare const TEXT_PLAIN = "text/plain";
+export declare const CONTENT_TYPE_ANY = "*/*";
 export declare const MULTIPART_MIXED = "multipart/mixed";
 export declare const MULTIPART_MIXED_BOUNDARY = "multipart/mixed;boundary=";
 export declare const CONTENT_TRANSFER_ENCODING = "Content-Transfer-Encoding";

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';
@@ -10,3 +11,4 @@ export * from './schema/index';
 export * from './models/index';
 export * from './resources/index';
 export * from './cache/index';
+export * from './metadata/index';

package/lib/loaders.d.ts

@@ -10,6 +10,12 @@ export declare class ODataConfigSyncLoader implements ODataConfigLoader {
 }
 export declare class ODataConfigAsyncLoader implements ODataConfigLoader {
     private readonly configs$;
-    constructor(configs$: Observable<ApiConfig> | Observable<ApiConfig>[] | Observable<ApiConfig[]>);
+    constructor(configs$: Observable<ApiConfig>[] | Observable<ApiConfig | ApiConfig[]>);
+    loadConfigs(): Observable<ApiConfig[]>;
+}
+export declare class ODataMetadataLoader implements ODataConfigLoader {
+    private readonly sources$;
+    private readonly baseConfigs;
+    constructor(sources$: Observable<string | string[]>, baseConfigs: ApiConfig | ApiConfig[]);
     loadConfigs(): Observable<ApiConfig[]>;
 }

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

@@ -0,0 +1,159 @@
+import { AnnotationConfig } 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;
+    Target: string;
+    Qualifier?: string;
+    constructor(schema: CsdlSchema, { Target, Qualifier, Annotation, }: {
+        Target: string;
+        Qualifier?: string;
+        Annotation: any[];
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): AnnotationConfig[];
+}
+export declare class CsdlAnnotation {
+    Term: string;
+    String?: string;
+    Bool?: boolean;
+    Int?: number;
+    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[];
+        EnumMember?: any[];
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(): AnnotationConfig;
+}
+export declare class CsdlTerm {
+    private schema;
+    Name: string;
+    Type: string;
+    BaseTerm?: string;
+    DefaultValue?: string;
+    AppliesTo?: string;
+    Nullable?: boolean;
+    MaxLength?: number;
+    Precision?: number;
+    Scale?: number;
+    SRID?: string;
+    String?: string;
+    Bool?: boolean;
+    Int?: number;
+    constructor(schema: CsdlSchema, { Name, Type, BaseTerm, DefaultValue, AppliesTo, Nullable, MaxLength, Precision, Scale, SRID, String, Bool, Int, }: {
+        Name: string;
+        Type: string;
+        BaseTerm?: string;
+        DefaultValue?: string;
+        AppliesTo?: string;
+        Nullable?: boolean;
+        MaxLength?: number;
+        Precision?: number;
+        Scale?: number;
+        SRID?: string;
+        String?: string;
+        Bool?: boolean;
+        Int?: number;
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+}
+export declare class CsdlCollection {
+    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 {
+    PropertyValue: CsdlPropertyValue[];
+    constructor({ PropertyValue }: {
+        PropertyValue: any[];
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+}
+export declare class CsdlPropertyValue {
+    Name: string;
+    String?: string;
+    Date?: Date;
+    EnumMember?: CsdlEnumMember[];
+    constructor({ Name, String, Date, EnumMember, }: {
+        Name: string;
+        String?: string;
+        Date?: Date;
+        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

@@ -0,0 +1,31 @@
+import { CsdlEntitySet } from './csdl-entity-set';
+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';
+export declare class CsdlEntityContainer extends CsdlAnnotable {
+    private schema;
+    Name: string;
+    Extend?: string;
+    EntitySet?: CsdlEntitySet[];
+    Singleton?: CsdlSingleton[];
+    FunctionImport?: CsdlFunctionImport[];
+    ActionImport?: CsdlActionImport[];
+    constructor(schema: CsdlSchema, { Name, Extend, EntitySet, Singleton, FunctionImport, ActionImport, Annotation, }: {
+        Name: string;
+        Extend?: string;
+        EntitySet?: any[];
+        Singleton?: any[];
+        FunctionImport?: any[];
+        ActionImport?: any[];
+        Annotation?: any[];
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
+    fullName(): string;
+    toConfig(base?: Partial<EntityContainerConfig>): EntityContainerConfig;
+}

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

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

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

@@ -0,0 +1,37 @@
+import { EnumTypeConfig, EnumTypeFieldConfig } from '../../types';
+import { CsdlAnnotable } from './csdl-annotation';
+import type { CsdlSchema } from './csdl-schema';
+export declare class CsdlEnumType extends CsdlAnnotable {
+    private schema;
+    Name: string;
+    Member: CsdlMember[];
+    UnderlyingType?: string;
+    IsFlags?: boolean;
+    constructor(schema: CsdlSchema, { Name, Member, UnderlyingType, IsFlags, Annotation, }: {
+        Name: string;
+        Member: any[];
+        UnderlyingType?: string;
+        IsFlags?: boolean;
+        Annotation?: any[];
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
+    fullName(): string;
+    toConfig(base?: Partial<EnumTypeConfig>): EnumTypeConfig;
+}
+export declare class CsdlMember extends CsdlAnnotable {
+    Name: string;
+    Value?: number;
+    constructor({ Name, Value, Annotation, }: {
+        Name: string;
+        Value?: number;
+        Annotation?: any[];
+    });
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(base?: Partial<EnumTypeFieldConfig>): EnumTypeFieldConfig;
+}

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

@@ -0,0 +1,148 @@
+import { CallableConfig, ParameterConfig } 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;
+    Parameter?: CsdlParameter[];
+    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
+        Name: string;
+        ReturnType?: any;
+        IsBound?: boolean;
+        EntitySetPath?: string;
+        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, Parameter, }: {
+        Name: string;
+        ReturnType: any;
+        IsBound?: boolean;
+        EntitySetPath?: string;
+        IsComposable?: boolean;
+        Parameter?: any[];
+    });
+    toJson(): {
+        IsComposable: boolean | undefined;
+    };
+    toConfig(base?: Partial<CallableConfig>): CallableConfig;
+}
+export declare class CsdlAction extends CsdlCallable {
+    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
+        Name: string;
+        ReturnType?: any;
+        IsBound?: boolean;
+        EntitySetPath?: string;
+        Parameter?: any[];
+    });
+    toJson(): {
+        [x: string]: any;
+    };
+    toConfig(base?: Partial<CallableConfig>): CallableConfig;
+}
+export declare class CsdlFunctionImport {
+    private container;
+    Name: string;
+    FunctionName: string;
+    EntitySet?: string;
+    IncludeInServiceDocument?: boolean;
+    constructor(container: CsdlEntityContainer, { Name, FunctionName, EntitySet, IncludeInServiceDocument, }: {
+        Name: string;
+        FunctionName: string;
+        EntitySet?: string;
+        IncludeInServiceDocument?: boolean;
+    });
+    toJson(): {
+        Name: string;
+        FunctionName: string;
+        EntitySet: string | undefined;
+        IncludeInServiceDocument: boolean | undefined;
+    };
+}
+export declare class CsdlActionImport {
+    private container;
+    Name: string;
+    Action: string;
+    EntitySet?: string;
+    constructor(container: CsdlEntityContainer, { Name, Action, EntitySet, }: {
+        Name: string;
+        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;
+    Scale?: number;
+    SRID?: string;
+    constructor({ Name, Type, Nullable, MaxLength, Precision, Scale, SRID, Annotation, }: {
+        Name: string;
+        Type: string;
+        Nullable?: boolean;
+        MaxLength?: number;
+        Precision?: number;
+        Scale?: number;
+        SRID?: string;
+        Annotation?: any[];
+    });
+    toJson(): {
+        Name: string;
+        Type: string;
+        Nullable: boolean | undefined;
+        MaxLength: number | undefined;
+        Precision: number | undefined;
+        Scale: number | undefined;
+        SRID: string | undefined;
+    };
+    toConfig(): ParameterConfig;
+}
+export declare class CsdlReturnType {
+    Type: string;
+    Collection: boolean;
+    Nullable?: boolean;
+    MaxLength?: number;
+    Precision?: number;
+    Scale?: number;
+    SRID?: string;
+    constructor({ Type, Nullable, MaxLength, Precision, Scale, SRID, }: {
+        Type: string;
+        Nullable?: boolean;
+        MaxLength?: number;
+        Precision?: number;
+        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;
+    } | undefined;
+}

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

@@ -0,0 +1,12 @@
+export declare class CsdlNavigationPropertyBinding {
+    Path: string;
+    Target: string;
+    constructor({ Path, Target }: {
+        Path: string;
+        Target: string;
+    });
+    toJson(): {
+        Path: string;
+        Target: string;
+    };
+}

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

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