Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@sap-ux/vocabularies-types

Package Overview
Dependencies
Maintainers
3
Versions
55
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@sap-ux/vocabularies-types - npm Package Compare versions

Comparing version 0.5.7 to 0.6.0

8

Edm.d.ts

@@ -17,3 +17,5 @@ import type { ActionAnnotations, ActionImportAnnotations, AnnotationAnnotations, ComplexTypeAnnotations, EntityContainerAnnotations, EntitySetAnnotations, EntityTypeAnnotations, EnumTypeAnnotations, FunctionAnnotations, FunctionImportAnnotations, IncludeAnnotations, NavigationPropertyAnnotations, ParameterAnnotations, PropertyAnnotations, ReferenceAnnotations, ReturnTypeAnnotations, SchemaAnnotations, SingletonAnnotations, TermAnnotations, TypeDefinitionAnnotations, PropertyValueAnnotations, RecordAnnotations, CollectionAnnotations } from './vocabularies/Edm_Types';

value: string;
$target: AnnotationTerm<P>;
$target: AnnotationTerm<P> & {
term: string;
};
};

@@ -23,3 +25,2 @@ declare type PrimitiveTypeCast<P, G> = (P extends boolean ? boolean | (Boolean & G) : never) | (P extends number ? number | (Number & G) : never) | (P extends string ? string | (String & G) : never) | (P & G);

fullyQualifiedName: string;
term: string;
qualifier: string;

@@ -158,2 +159,3 @@ annotations?: TermAnnotations & AnnotationAnnotations;

annotations?: RecordAnnotations;
fullyQualifiedName: string;
};

@@ -285,3 +287,3 @@ export declare type ComplexType = {

}[];
resolvePath: <T>(path: string) => ResolutionTarget<T>;
resolvePath: <T>(path: string, resolveDirectly?: boolean) => ResolutionTarget<T>;
};

@@ -288,0 +290,0 @@ declare type RemoveAnnotationAndType<T> = {

2

package.json
{
"name": "@sap-ux/vocabularies-types",
"version": "0.5.7",
"version": "0.6.0",
"description": "SAP Fiori OData - TS types for vocabularies",

@@ -5,0 +5,0 @@ "repository": {

60

vocabularies/Aggregation.d.ts

@@ -10,7 +10,11 @@ import * as Core from "./Core";

*/
export declare type ApplySupported = AnnotationTerm<ApplySupportedTypeTypes>;
export declare type ApplySupported = {
term: AggregationAnnotationTerms.ApplySupported;
} & AnnotationTerm<ApplySupportedTypeTypes>;
/**
Default support of the `$apply` system query option for all collection-valued resources in the container
*/
export declare type ApplySupportedDefaults = AnnotationTerm<ApplySupportedBaseTypes>;
export declare type ApplySupportedDefaults = {
term: AggregationAnnotationTerms.ApplySupportedDefaults;
} & AnnotationTerm<ApplySupportedBaseTypes>;
export declare type ApplySupportedBase = ComplexType & {

@@ -44,3 +48,3 @@ $Type: AggregationAnnotationTypes.ApplySupportedBase;

*/
AggregatableProperties: AnnotationTerm<AggregatablePropertyTypeTypes[]>;
AggregatableProperties: AggregatablePropertyTypeTypes[];
};

@@ -91,23 +95,35 @@ export declare type AggregatablePropertyType = ComplexType & {

*/
export declare type Groupable = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Groupable = {
term: AggregationAnnotationTerms.Groupable;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
This property can be used in the `aggregate` transformation
*/
export declare type Aggregatable = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Aggregatable = {
term: AggregationAnnotationTerms.Aggregatable;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Dynamic property that can be used in the `aggregate` transformation
*/
export declare type CustomAggregate = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type CustomAggregate = {
term: AggregationAnnotationTerms.CustomAggregate;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The annotated property or custom aggregate is only well-defined in the context of these properties
*/
export declare type ContextDefiningProperties = AnnotationTerm<Edm.PropertyPath[]>;
export declare type ContextDefiningProperties = {
term: AggregationAnnotationTerms.ContextDefiningProperties;
} & AnnotationTerm<Edm.PropertyPath[]>;
/**
Defines a leveled hierarchy by defining an ordered list of properties in the hierarchy
*/
export declare type LeveledHierarchy = AnnotationTerm<Edm.PropertyPath[]>;
export declare type LeveledHierarchy = {
term: AggregationAnnotationTerms.LeveledHierarchy;
} & AnnotationTerm<Edm.PropertyPath[]>;
/**
Defines a recursive hierarchy.
*/
export declare type RecursiveHierarchy = AnnotationTerm<RecursiveHierarchyTypeTypes>;
export declare type RecursiveHierarchy = {
term: AggregationAnnotationTerms.RecursiveHierarchy;
} & AnnotationTerm<RecursiveHierarchyTypeTypes>;
export declare type RecursiveHierarchyType = ComplexType & {

@@ -122,3 +138,3 @@ $Type: AggregationAnnotationTypes.RecursiveHierarchyType;

*/
ParentNavigationProperty: PropertyAnnotationValue<Edm.NavigationPropertyPath>;
ParentNavigationProperty: Edm.NavigationPropertyPath;
/**

@@ -156,3 +172,5 @@ Property holding the number of edges between the node and the root node

*/
export declare type AvailableOnAggregates = AnnotationTerm<AvailableOnAggregatesTypeTypes>;
export declare type AvailableOnAggregates = {
term: AggregationAnnotationTerms.AvailableOnAggregates;
} & AnnotationTerm<AvailableOnAggregatesTypeTypes>;
export declare type AvailableOnAggregatesType = ComplexType & {

@@ -173,7 +191,7 @@ $Type: AggregationAnnotationTypes.AvailableOnAggregatesType;

*/
ApplySupported?: AnnotationTerm<ApplySupportedTypeTypes>;
ApplySupported?: ApplySupportedTypeTypes;
/**
Supported custom aggregates
*/
CustomAggregates: AnnotationTerm<CustomAggregateTypeTypes[]>;
CustomAggregates: CustomAggregateTypeTypes[];
};

@@ -211,9 +229,9 @@ export declare type CustomAggregateType = ComplexType & {

}
export declare type ApplySupportedBaseTypes = AnnotationTerm<ApplySupportedBase | ApplySupportedTypeTypes>;
export declare type ApplySupportedTypeTypes = AnnotationTerm<ApplySupportedType>;
export declare type AggregatablePropertyTypeTypes = AnnotationTerm<AggregatablePropertyType>;
export declare type RecursiveHierarchyTypeTypes = AnnotationTerm<RecursiveHierarchyType>;
export declare type AvailableOnAggregatesTypeTypes = AnnotationTerm<AvailableOnAggregatesType>;
export declare type NavigationPropertyAggregationCapabilitiesTypes = AnnotationTerm<NavigationPropertyAggregationCapabilities>;
export declare type NavigationPropertyRestrictionTypes = AnnotationTerm<Capabilities.NavigationPropertyRestriction | NavigationPropertyAggregationCapabilitiesTypes>;
export declare type CustomAggregateTypeTypes = AnnotationTerm<CustomAggregateType>;
export declare type ApplySupportedBaseTypes = ApplySupportedBase | ApplySupportedTypeTypes;
export declare type ApplySupportedTypeTypes = ApplySupportedType;
export declare type AggregatablePropertyTypeTypes = AggregatablePropertyType;
export declare type RecursiveHierarchyTypeTypes = RecursiveHierarchyType;
export declare type AvailableOnAggregatesTypeTypes = AvailableOnAggregatesType;
export declare type NavigationPropertyAggregationCapabilitiesTypes = NavigationPropertyAggregationCapabilities;
export declare type NavigationPropertyRestrictionTypes = Capabilities.NavigationPropertyRestriction | NavigationPropertyAggregationCapabilitiesTypes;
export declare type CustomAggregateTypeTypes = CustomAggregateType;

40

vocabularies/Analytics.d.ts

@@ -11,15 +11,23 @@ import * as Core from "./Core";

*/
export declare type Dimension = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Dimension = {
term: AnalyticsAnnotationTerms.Dimension;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
A property holding the numeric value of a measure in an analytical context
*/
export declare type Measure = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Measure = {
term: AnalyticsAnnotationTerms.Measure;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
The measure has non-negative and additive values; it can be used in whole-part charts, e.g. the Donut
*/
export declare type AccumulativeMeasure = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type AccumulativeMeasure = {
term: AnalyticsAnnotationTerms.AccumulativeMeasure;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Number of properties in the entity instance that have been aggregated away
*/
export declare type RolledUpPropertyCount = AnnotationTerm<Edm.Int16>;
export declare type RolledUpPropertyCount = {
term: AnalyticsAnnotationTerms.RolledUpPropertyCount;
} & AnnotationTerm<Edm.Int16>;
/**

@@ -31,3 +39,5 @@

*/
export declare type DrillURL = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type DrillURL = {
term: AnalyticsAnnotationTerms.DrillURL;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**

@@ -37,11 +47,17 @@ Processes or generates plan data. Its logic may have side-effects on entity sets.

*/
export declare type PlanningAction = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type PlanningAction = {
term: AnalyticsAnnotationTerms.PlanningAction;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Dynamic properties for aggregate expressions with specified aggregation method defined on the annotated entity type.
*/
export declare type AggregatedProperties = AnnotationTerm<AggregatedPropertyTypeTypes[]>;
export declare type AggregatedProperties = {
term: AnalyticsAnnotationTerms.AggregatedProperties;
} & AnnotationTerm<AggregatedPropertyTypeTypes[]>;
/**
Dynamic property for aggregate expression with specified aggregation method defined on the annotated entity type.
*/
export declare type AggregatedProperty = AnnotationTerm<AggregatedPropertyTypeTypes>;
export declare type AggregatedProperty = {
term: AnalyticsAnnotationTerms.AggregatedProperty;
} & AnnotationTerm<AggregatedPropertyTypeTypes>;
export declare type AggregatedPropertyType = ComplexType & {

@@ -65,3 +81,5 @@ $Type: AnalyticsAnnotationTypes.AggregatedPropertyType;

*/
export declare type AnalyticalContext = AnnotationTerm<AnalyticalContextTypeTypes[]>;
export declare type AnalyticalContext = {
term: AnalyticsAnnotationTerms.AnalyticalContext;
} & AnnotationTerm<AnalyticalContextTypeTypes[]>;
/**

@@ -108,3 +126,3 @@ Exactly one of `Property` and `DynamicProperty` must be present

}
export declare type AggregatedPropertyTypeTypes = AnnotationTerm<AggregatedPropertyType>;
export declare type AnalyticalContextTypeTypes = AnnotationTerm<AnalyticalContextType>;
export declare type AggregatedPropertyTypeTypes = AggregatedPropertyType;
export declare type AnalyticalContextTypeTypes = AnalyticalContextType;

32

vocabularies/Auth.d.ts

@@ -8,3 +8,5 @@ import * as Edm from "../Edm";

*/
export declare type SecuritySchemes = AnnotationTerm<SecuritySchemeTypes[]>;
export declare type SecuritySchemes = {
term: AuthAnnotationTerms.SecuritySchemes;
} & AnnotationTerm<SecuritySchemeTypes[]>;
export declare type SecurityScheme = ComplexType & {

@@ -24,3 +26,5 @@ $Type: AuthAnnotationTypes.SecurityScheme;

*/
export declare type Authorizations = AnnotationTerm<AuthorizationTypes[]>;
export declare type Authorizations = {
term: AuthAnnotationTerms.Authorizations;
} & AnnotationTerm<AuthorizationTypes[]>;
/**

@@ -63,3 +67,3 @@ Base type for all Authorization types

*/
Scopes: AnnotationTerm<AuthorizationScopeTypes[]>;
Scopes: AuthorizationScopeTypes[];
/**

@@ -172,12 +176,12 @@ Refresh Url

}
export declare type SecuritySchemeTypes = AnnotationTerm<SecurityScheme>;
export declare type AuthorizationTypes = AnnotationTerm<OpenIDConnectTypes | HttpTypes | OAuthAuthorizationTypes | ApiKeyTypes>;
export declare type OpenIDConnectTypes = AnnotationTerm<OpenIDConnect>;
export declare type HttpTypes = AnnotationTerm<Http>;
export declare type OAuthAuthorizationTypes = AnnotationTerm<OAuth2ClientCredentialsTypes | OAuth2ImplicitTypes | OAuth2PasswordTypes | OAuth2AuthCodeTypes>;
export declare type OAuth2ClientCredentialsTypes = AnnotationTerm<OAuth2ClientCredentials>;
export declare type OAuth2ImplicitTypes = AnnotationTerm<OAuth2Implicit>;
export declare type OAuth2PasswordTypes = AnnotationTerm<OAuth2Password>;
export declare type OAuth2AuthCodeTypes = AnnotationTerm<OAuth2AuthCode>;
export declare type AuthorizationScopeTypes = AnnotationTerm<AuthorizationScope>;
export declare type ApiKeyTypes = AnnotationTerm<ApiKey>;
export declare type SecuritySchemeTypes = SecurityScheme;
export declare type AuthorizationTypes = OpenIDConnectTypes | HttpTypes | OAuthAuthorizationTypes | ApiKeyTypes;
export declare type OpenIDConnectTypes = OpenIDConnect;
export declare type HttpTypes = Http;
export declare type OAuthAuthorizationTypes = OAuth2ClientCredentialsTypes | OAuth2ImplicitTypes | OAuth2PasswordTypes | OAuth2AuthCodeTypes;
export declare type OAuth2ClientCredentialsTypes = OAuth2ClientCredentials;
export declare type OAuth2ImplicitTypes = OAuth2Implicit;
export declare type OAuth2PasswordTypes = OAuth2Password;
export declare type OAuth2AuthCodeTypes = OAuth2AuthCode;
export declare type AuthorizationScopeTypes = AuthorizationScope;
export declare type ApiKeyTypes = ApiKey;

288

vocabularies/Capabilities.d.ts

@@ -38,19 +38,29 @@ import * as Auth from "./Auth";

*/
export declare type SupportedFormats = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type SupportedFormats = {
term: CapabilitiesAnnotationTerms.SupportedFormats;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
Media types of supported formats for $metadata, including format parameters
*/
export declare type SupportedMetadataFormats = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type SupportedMetadataFormats = {
term: CapabilitiesAnnotationTerms.SupportedMetadataFormats;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
List of acceptable compression methods for ($batch) requests, e.g. gzip
*/
export declare type AcceptableEncodings = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type AcceptableEncodings = {
term: CapabilitiesAnnotationTerms.AcceptableEncodings;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
Service supports the asynchronous request preference
*/
export declare type AsynchronousRequestsSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type AsynchronousRequestsSupported = {
term: CapabilitiesAnnotationTerms.AsynchronousRequestsSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Service supports the continue on error preference. Supports $batch requests. Services that apply the BatchContinueOnErrorSupported term should also specify the ContinueOnErrorSupported property from the BatchSupport term.
*/
export declare type BatchContinueOnErrorSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type BatchContinueOnErrorSupported = {
term: CapabilitiesAnnotationTerms.BatchContinueOnErrorSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -72,7 +82,11 @@ Supported odata.isolation levels

*/
export declare type CrossJoinSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type CrossJoinSupported = {
term: CapabilitiesAnnotationTerms.CrossJoinSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Supports callbacks for the specified protocols
*/
export declare type CallbackSupported = AnnotationTerm<CallbackTypeTypes>;
export declare type CallbackSupported = {
term: CapabilitiesAnnotationTerms.CallbackSupported;
} & AnnotationTerm<CallbackTypeTypes>;
/**

@@ -86,3 +100,3 @@ A non-empty collection lists the full set of supported protocols. A empty collection means 'only HTTP is supported'

*/
CallbackProtocols: AnnotationTerm<CallbackProtocolTypes[]>;
CallbackProtocols: CallbackProtocolTypes[];
};

@@ -107,3 +121,5 @@ export declare type CallbackProtocol = ComplexType & {

*/
export declare type ChangeTracking = AnnotationTerm<ChangeTrackingTypeTypes>;
export declare type ChangeTracking = {
term: CapabilitiesAnnotationTerms.ChangeTracking;
} & AnnotationTerm<ChangeTrackingTypeTypes>;
export declare type ChangeTrackingType = ComplexType & {

@@ -122,3 +138,3 @@ $Type: CapabilitiesAnnotationTypes.ChangeTrackingType;

*/
ExpandableProperties: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
ExpandableProperties: Edm.NavigationPropertyPath[];
};

@@ -128,3 +144,5 @@ /**

*/
export declare type CountRestrictions = AnnotationTerm<CountRestrictionsTypeTypes>;
export declare type CountRestrictions = {
term: CapabilitiesAnnotationTerms.CountRestrictions;
} & AnnotationTerm<CountRestrictionsTypeTypes>;
export declare type CountRestrictionsType = ComplexType & {

@@ -143,3 +161,3 @@ $Type: CapabilitiesAnnotationTypes.CountRestrictionsType;

*/
NonCountableNavigationProperties: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
NonCountableNavigationProperties: Edm.NavigationPropertyPath[];
};

@@ -149,3 +167,5 @@ /**

*/
export declare type NavigationRestrictions = AnnotationTerm<NavigationRestrictionsTypeTypes>;
export declare type NavigationRestrictions = {
term: CapabilitiesAnnotationTerms.NavigationRestrictions;
} & AnnotationTerm<NavigationRestrictionsTypeTypes>;
export declare type NavigationRestrictionsType = ComplexType & {

@@ -160,3 +180,3 @@ $Type: CapabilitiesAnnotationTypes.NavigationRestrictionsType;

*/
RestrictedProperties: AnnotationTerm<NavigationPropertyRestrictionTypes[]>;
RestrictedProperties: NavigationPropertyRestrictionTypes[];
};

@@ -168,3 +188,3 @@ export declare type NavigationPropertyRestriction = ComplexType & {

*/
NavigationProperty: PropertyAnnotationValue<Edm.NavigationPropertyPath>;
NavigationProperty: Edm.NavigationPropertyPath;
/**

@@ -181,11 +201,11 @@ Supported navigability of this navigation property

*/
FilterRestrictions?: AnnotationTerm<FilterRestrictionsTypeTypes>;
FilterRestrictions?: FilterRestrictionsTypeTypes;
/**
Restrictions on search expressions
*/
SearchRestrictions?: AnnotationTerm<SearchRestrictionsTypeTypes>;
SearchRestrictions?: SearchRestrictionsTypeTypes;
/**
Restrictions on orderby expressions
*/
SortRestrictions?: AnnotationTerm<SortRestrictionsTypeTypes>;
SortRestrictions?: SortRestrictionsTypeTypes;
/**

@@ -202,3 +222,3 @@ Supports $top

*/
SelectSupport?: AnnotationTerm<SelectSupportTypeTypes>;
SelectSupport?: SelectSupportTypeTypes;
/**

@@ -211,19 +231,19 @@ Supports key values according to OData URL conventions

*/
InsertRestrictions?: AnnotationTerm<InsertRestrictionsTypeTypes>;
InsertRestrictions?: InsertRestrictionsTypeTypes;
/**
Deep Insert Support of the annotated resource (the whole service, an entity set, or a collection-valued resource)
*/
DeepInsertSupport?: AnnotationTerm<DeepInsertSupportTypeTypes>;
DeepInsertSupport?: DeepInsertSupportTypeTypes;
/**
Restrictions on update operations
*/
UpdateRestrictions?: AnnotationTerm<UpdateRestrictionsTypeTypes>;
UpdateRestrictions?: UpdateRestrictionsTypeTypes;
/**
Deep Update Support of the annotated resource (the whole service, an entity set, or a collection-valued resource)
*/
DeepUpdateSupport?: AnnotationTerm<DeepUpdateSupportTypeTypes>;
DeepUpdateSupport?: DeepUpdateSupportTypeTypes;
/**
Restrictions on delete operations
*/
DeleteRestrictions?: AnnotationTerm<DeleteRestrictionsTypeTypes>;
DeleteRestrictions?: DeleteRestrictionsTypeTypes;
/**

@@ -236,3 +256,3 @@ Data modification (including insert) along this navigation property requires the use of ETags

*/
ReadRestrictions?: AnnotationTerm<ReadRestrictionsTypeTypes>;
ReadRestrictions?: ReadRestrictionsTypeTypes;
};

@@ -265,19 +285,29 @@ export declare const enum NavigationType {

*/
export declare type IndexableByKey = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IndexableByKey = {
term: CapabilitiesAnnotationTerms.IndexableByKey;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Supports $top
*/
export declare type TopSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type TopSupported = {
term: CapabilitiesAnnotationTerms.TopSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Supports $skip
*/
export declare type SkipSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type SkipSupported = {
term: CapabilitiesAnnotationTerms.SkipSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Supports $compute
*/
export declare type ComputeSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type ComputeSupported = {
term: CapabilitiesAnnotationTerms.ComputeSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Support for $select and nested query options within $select
*/
export declare type SelectSupport = AnnotationTerm<SelectSupportTypeTypes>;
export declare type SelectSupport = {
term: CapabilitiesAnnotationTerms.SelectSupport;
} & AnnotationTerm<SelectSupportTypeTypes>;
export declare type SelectSupportType = ComplexType & {

@@ -329,7 +359,11 @@ $Type: CapabilitiesAnnotationTypes.SelectSupportType;

*/
export declare type BatchSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type BatchSupported = {
term: CapabilitiesAnnotationTerms.BatchSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Batch Support for the service
*/
export declare type BatchSupport = AnnotationTerm<BatchSupportTypeTypes>;
export declare type BatchSupport = {
term: CapabilitiesAnnotationTerms.BatchSupport;
} & AnnotationTerm<BatchSupportTypeTypes>;
export declare type BatchSupportType = ComplexType & {

@@ -369,7 +403,11 @@ $Type: CapabilitiesAnnotationTypes.BatchSupportType;

*/
export declare type FilterFunctions = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type FilterFunctions = {
term: CapabilitiesAnnotationTerms.FilterFunctions;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
Restrictions on filter expressions
*/
export declare type FilterRestrictions = AnnotationTerm<FilterRestrictionsTypeTypes>;
export declare type FilterRestrictions = {
term: CapabilitiesAnnotationTerms.FilterRestrictions;
} & AnnotationTerm<FilterRestrictionsTypeTypes>;
export declare type FilterRestrictionsType = ComplexType & {

@@ -396,3 +434,3 @@ $Type: CapabilitiesAnnotationTypes.FilterRestrictionsType;

*/
FilterExpressionRestrictions: AnnotationTerm<FilterExpressionRestrictionTypeTypes[]>;
FilterExpressionRestrictions: FilterExpressionRestrictionTypeTypes[];
/**

@@ -418,3 +456,5 @@ The maximum number of levels (including recursion) that can be traversed in a filter expression. A value of -1 indicates there is no restriction.

*/
export declare type SortRestrictions = AnnotationTerm<SortRestrictionsTypeTypes>;
export declare type SortRestrictions = {
term: CapabilitiesAnnotationTerms.SortRestrictions;
} & AnnotationTerm<SortRestrictionsTypeTypes>;
export declare type SortRestrictionsType = ComplexType & {

@@ -442,3 +482,5 @@ $Type: CapabilitiesAnnotationTypes.SortRestrictionsType;

*/
export declare type ExpandRestrictions = AnnotationTerm<ExpandRestrictionsTypeTypes>;
export declare type ExpandRestrictions = {
term: CapabilitiesAnnotationTerms.ExpandRestrictions;
} & AnnotationTerm<ExpandRestrictionsTypeTypes>;
export declare type ExpandRestrictionsType = ComplexType & {

@@ -457,3 +499,3 @@ $Type: CapabilitiesAnnotationTypes.ExpandRestrictionsType;

*/
NonExpandableProperties: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
NonExpandableProperties: Edm.NavigationPropertyPath[];
/**

@@ -471,3 +513,5 @@ These stream properties cannot be used in expand expressions

*/
export declare type SearchRestrictions = AnnotationTerm<SearchRestrictionsTypeTypes>;
export declare type SearchRestrictions = {
term: CapabilitiesAnnotationTerms.SearchRestrictions;
} & AnnotationTerm<SearchRestrictionsTypeTypes>;
export declare type SearchRestrictionsType = ComplexType & {

@@ -531,11 +575,17 @@ $Type: CapabilitiesAnnotationTypes.SearchRestrictionsType;

*/
export declare type KeyAsSegmentSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type KeyAsSegmentSupported = {
term: CapabilitiesAnnotationTerms.KeyAsSegmentSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Supports [passing query options in the request body](http://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_PassingQueryOptionsintheRequestBody)
*/
export declare type QuerySegmentSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type QuerySegmentSupported = {
term: CapabilitiesAnnotationTerms.QuerySegmentSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Restrictions on insert operations
*/
export declare type InsertRestrictions = AnnotationTerm<InsertRestrictionsTypeTypes>;
export declare type InsertRestrictions = {
term: CapabilitiesAnnotationTerms.InsertRestrictions;
} & AnnotationTerm<InsertRestrictionsTypeTypes>;
export declare type InsertRestrictionsType = ComplexType & {

@@ -554,3 +604,3 @@ $Type: CapabilitiesAnnotationTypes.InsertRestrictionsType;

*/
NonInsertableNavigationProperties: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
NonInsertableNavigationProperties: Edm.NavigationPropertyPath[];
/**

@@ -571,15 +621,15 @@ These structural properties must be specified on insert

*/
Permissions?: AnnotationTerm<PermissionTypeTypes[]>;
Permissions?: PermissionTypeTypes[];
/**
Support for query options with insert requests
*/
QueryOptions?: AnnotationTerm<ModificationQueryOptionsTypeTypes>;
QueryOptions?: ModificationQueryOptionsTypeTypes;
/**
Supported or required custom headers
*/
CustomHeaders: AnnotationTerm<CustomParameterTypes[]>;
CustomHeaders: CustomParameterTypes[];
/**
Supported or required custom query options
*/
CustomQueryOptions: AnnotationTerm<CustomParameterTypes[]>;
CustomQueryOptions: CustomParameterTypes[];
/**

@@ -603,3 +653,3 @@ A brief description of the request

*/
Scopes: AnnotationTerm<ScopeTypeTypes[]>;
Scopes: ScopeTypeTypes[];
};

@@ -620,3 +670,5 @@ export declare type ScopeType = ComplexType & {

*/
export declare type DeepInsertSupport = AnnotationTerm<DeepInsertSupportTypeTypes>;
export declare type DeepInsertSupport = {
term: CapabilitiesAnnotationTerms.DeepInsertSupport;
} & AnnotationTerm<DeepInsertSupportTypeTypes>;
export declare type DeepInsertSupportType = ComplexType & {

@@ -636,3 +688,5 @@ $Type: CapabilitiesAnnotationTypes.DeepInsertSupportType;

*/
export declare type UpdateRestrictions = AnnotationTerm<UpdateRestrictionsTypeTypes>;
export declare type UpdateRestrictions = {
term: CapabilitiesAnnotationTerms.UpdateRestrictions;
} & AnnotationTerm<UpdateRestrictionsTypeTypes>;
export declare type UpdateRestrictionsType = ComplexType & {

@@ -671,3 +725,3 @@ $Type: CapabilitiesAnnotationTypes.UpdateRestrictionsType;

*/
NonUpdatableNavigationProperties: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
NonUpdatableNavigationProperties: Edm.NavigationPropertyPath[];
/**

@@ -684,15 +738,15 @@ These structural properties must be specified on update

*/
Permissions?: AnnotationTerm<PermissionTypeTypes[]>;
Permissions?: PermissionTypeTypes[];
/**
Support for query options with update requests
*/
QueryOptions?: AnnotationTerm<ModificationQueryOptionsTypeTypes>;
QueryOptions?: ModificationQueryOptionsTypeTypes;
/**
Supported or required custom headers
*/
CustomHeaders: AnnotationTerm<CustomParameterTypes[]>;
CustomHeaders: CustomParameterTypes[];
/**
Supported or required custom query options
*/
CustomQueryOptions: AnnotationTerm<CustomParameterTypes[]>;
CustomQueryOptions: CustomParameterTypes[];
/**

@@ -761,3 +815,5 @@ A brief description of the request

*/
export declare type DeepUpdateSupport = AnnotationTerm<DeepUpdateSupportTypeTypes>;
export declare type DeepUpdateSupport = {
term: CapabilitiesAnnotationTerms.DeepUpdateSupport;
} & AnnotationTerm<DeepUpdateSupportTypeTypes>;
export declare type DeepUpdateSupportType = ComplexType & {

@@ -777,3 +833,5 @@ $Type: CapabilitiesAnnotationTypes.DeepUpdateSupportType;

*/
export declare type DeleteRestrictions = AnnotationTerm<DeleteRestrictionsTypeTypes>;
export declare type DeleteRestrictions = {
term: CapabilitiesAnnotationTerms.DeleteRestrictions;
} & AnnotationTerm<DeleteRestrictionsTypeTypes>;
export declare type DeleteRestrictionsType = ComplexType & {

@@ -788,3 +846,3 @@ $Type: CapabilitiesAnnotationTypes.DeleteRestrictionsType;

*/
NonDeletableNavigationProperties: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
NonDeletableNavigationProperties: Edm.NavigationPropertyPath[];
/**

@@ -805,11 +863,11 @@ The maximum number of navigation properties that can be traversed when addressing the collection to delete from or the entity to delete. A value of -1 indicates there is no restriction.

*/
Permissions?: AnnotationTerm<PermissionTypeTypes[]>;
Permissions?: PermissionTypeTypes[];
/**
Supported or required custom headers
*/
CustomHeaders: AnnotationTerm<CustomParameterTypes[]>;
CustomHeaders: CustomParameterTypes[];
/**
Supported or required custom query options
*/
CustomQueryOptions: AnnotationTerm<CustomParameterTypes[]>;
CustomQueryOptions: CustomParameterTypes[];
/**

@@ -827,3 +885,5 @@ A brief description of the request

*/
export declare type CollectionPropertyRestrictions = AnnotationTerm<CollectionPropertyRestrictionsTypeTypes[]>;
export declare type CollectionPropertyRestrictions = {
term: CapabilitiesAnnotationTerms.CollectionPropertyRestrictions;
} & AnnotationTerm<CollectionPropertyRestrictionsTypeTypes[]>;
export declare type CollectionPropertyRestrictionsType = ComplexType & {

@@ -842,11 +902,11 @@ $Type: CapabilitiesAnnotationTypes.CollectionPropertyRestrictionsType;

*/
FilterRestrictions?: AnnotationTerm<FilterRestrictionsTypeTypes>;
FilterRestrictions?: FilterRestrictionsTypeTypes;
/**
Restrictions on search expressions
*/
SearchRestrictions?: AnnotationTerm<SearchRestrictionsTypeTypes>;
SearchRestrictions?: SearchRestrictionsTypeTypes;
/**
Restrictions on orderby expressions
*/
SortRestrictions?: AnnotationTerm<SortRestrictionsTypeTypes>;
SortRestrictions?: SortRestrictionsTypeTypes;
/**

@@ -863,3 +923,3 @@ Supports $top

*/
SelectSupport?: AnnotationTerm<SelectSupportTypeTypes>;
SelectSupport?: SelectSupportTypeTypes;
/**

@@ -881,3 +941,5 @@ Members can be inserted into this collection

*/
export declare type OperationRestrictions = AnnotationTerm<OperationRestrictionsTypeTypes>;
export declare type OperationRestrictions = {
term: CapabilitiesAnnotationTerms.OperationRestrictions;
} & AnnotationTerm<OperationRestrictionsTypeTypes>;
export declare type OperationRestrictionsType = ComplexType & {

@@ -892,11 +954,11 @@ $Type: CapabilitiesAnnotationTypes.OperationRestrictionsType;

*/
Permissions?: AnnotationTerm<PermissionTypeTypes[]>;
Permissions?: PermissionTypeTypes[];
/**
Supported or required custom headers
*/
CustomHeaders: AnnotationTerm<CustomParameterTypes[]>;
CustomHeaders: CustomParameterTypes[];
/**
Supported or required custom query options
*/
CustomQueryOptions: AnnotationTerm<CustomParameterTypes[]>;
CustomQueryOptions: CustomParameterTypes[];
};

@@ -906,7 +968,11 @@ /**

*/
export declare type AnnotationValuesInQuerySupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type AnnotationValuesInQuerySupported = {
term: CapabilitiesAnnotationTerms.AnnotationValuesInQuerySupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Support for query options with modification requests (insert, update, action invocation)
*/
export declare type ModificationQueryOptions = AnnotationTerm<ModificationQueryOptionsTypeTypes>;
export declare type ModificationQueryOptions = {
term: CapabilitiesAnnotationTerms.ModificationQueryOptions;
} & AnnotationTerm<ModificationQueryOptionsTypeTypes>;
export declare type ModificationQueryOptionsType = ComplexType & {

@@ -942,3 +1008,5 @@ $Type: CapabilitiesAnnotationTypes.ModificationQueryOptionsType;

*/
export declare type ReadRestrictions = AnnotationTerm<ReadRestrictionsTypeTypes>;
export declare type ReadRestrictions = {
term: CapabilitiesAnnotationTerms.ReadRestrictions;
} & AnnotationTerm<ReadRestrictionsTypeTypes>;
export declare type ReadRestrictionsBase = ComplexType & {

@@ -953,11 +1021,11 @@ $Type: CapabilitiesAnnotationTypes.ReadRestrictionsBase;

*/
Permissions?: AnnotationTerm<PermissionTypeTypes[]>;
Permissions?: PermissionTypeTypes[];
/**
Supported or required custom headers
*/
CustomHeaders: AnnotationTerm<CustomParameterTypes[]>;
CustomHeaders: CustomParameterTypes[];
/**
Supported or required custom query options
*/
CustomQueryOptions: AnnotationTerm<CustomParameterTypes[]>;
CustomQueryOptions: CustomParameterTypes[];
/**

@@ -983,3 +1051,3 @@ A brief description of the request

*/
ReadByKeyRestrictions?: AnnotationTerm<ReadByKeyRestrictionsTypeTypes>;
ReadByKeyRestrictions?: ReadByKeyRestrictionsTypeTypes;
};

@@ -989,7 +1057,11 @@ /**

*/
export declare type CustomHeaders = AnnotationTerm<CustomParameterTypes[]>;
export declare type CustomHeaders = {
term: CapabilitiesAnnotationTerms.CustomHeaders;
} & AnnotationTerm<CustomParameterTypes[]>;
/**
Custom query options that are supported/required for the annotated resource
*/
export declare type CustomQueryOptions = AnnotationTerm<CustomParameterTypes[]>;
export declare type CustomQueryOptions = {
term: CapabilitiesAnnotationTerms.CustomQueryOptions;
} & AnnotationTerm<CustomParameterTypes[]>;
/**

@@ -1024,3 +1096,5 @@ A custom parameter is either a header or a query option

*/
export declare type MediaLocationUpdateSupported = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type MediaLocationUpdateSupported = {
term: CapabilitiesAnnotationTerms.MediaLocationUpdateSupported;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare const enum CapabilitiesAnnotationTerms {

@@ -1096,28 +1170,28 @@ ConformanceLevel = "Org.OData.Capabilities.V1.ConformanceLevel",

}
export declare type CallbackTypeTypes = AnnotationTerm<CallbackType>;
export declare type CallbackProtocolTypes = AnnotationTerm<CallbackProtocol>;
export declare type ChangeTrackingTypeTypes = AnnotationTerm<ChangeTrackingType>;
export declare type CountRestrictionsTypeTypes = AnnotationTerm<CountRestrictionsType>;
export declare type NavigationRestrictionsTypeTypes = AnnotationTerm<NavigationRestrictionsType>;
export declare type NavigationPropertyRestrictionTypes = AnnotationTerm<NavigationPropertyRestriction>;
export declare type SelectSupportTypeTypes = AnnotationTerm<SelectSupportType>;
export declare type BatchSupportTypeTypes = AnnotationTerm<BatchSupportType>;
export declare type FilterRestrictionsTypeTypes = AnnotationTerm<FilterRestrictionsType>;
export declare type FilterExpressionRestrictionTypeTypes = AnnotationTerm<FilterExpressionRestrictionType>;
export declare type SortRestrictionsTypeTypes = AnnotationTerm<SortRestrictionsType>;
export declare type ExpandRestrictionsTypeTypes = AnnotationTerm<ExpandRestrictionsType>;
export declare type SearchRestrictionsTypeTypes = AnnotationTerm<SearchRestrictionsType>;
export declare type InsertRestrictionsTypeTypes = AnnotationTerm<InsertRestrictionsType>;
export declare type PermissionTypeTypes = AnnotationTerm<PermissionType>;
export declare type ScopeTypeTypes = AnnotationTerm<ScopeType>;
export declare type DeepInsertSupportTypeTypes = AnnotationTerm<DeepInsertSupportType>;
export declare type UpdateRestrictionsTypeTypes = AnnotationTerm<UpdateRestrictionsType>;
export declare type DeepUpdateSupportTypeTypes = AnnotationTerm<DeepUpdateSupportType>;
export declare type DeleteRestrictionsTypeTypes = AnnotationTerm<DeleteRestrictionsType>;
export declare type CollectionPropertyRestrictionsTypeTypes = AnnotationTerm<CollectionPropertyRestrictionsType>;
export declare type OperationRestrictionsTypeTypes = AnnotationTerm<OperationRestrictionsType>;
export declare type ModificationQueryOptionsTypeTypes = AnnotationTerm<ModificationQueryOptionsType>;
export declare type ReadRestrictionsBaseTypes = AnnotationTerm<ReadByKeyRestrictionsTypeTypes | ReadRestrictionsTypeTypes>;
export declare type ReadByKeyRestrictionsTypeTypes = AnnotationTerm<ReadByKeyRestrictionsType>;
export declare type ReadRestrictionsTypeTypes = AnnotationTerm<ReadRestrictionsType>;
export declare type CustomParameterTypes = AnnotationTerm<CustomParameter>;
export declare type CallbackTypeTypes = CallbackType;
export declare type CallbackProtocolTypes = CallbackProtocol;
export declare type ChangeTrackingTypeTypes = ChangeTrackingType;
export declare type CountRestrictionsTypeTypes = CountRestrictionsType;
export declare type NavigationRestrictionsTypeTypes = NavigationRestrictionsType;
export declare type NavigationPropertyRestrictionTypes = NavigationPropertyRestriction;
export declare type SelectSupportTypeTypes = SelectSupportType;
export declare type BatchSupportTypeTypes = BatchSupportType;
export declare type FilterRestrictionsTypeTypes = FilterRestrictionsType;
export declare type FilterExpressionRestrictionTypeTypes = FilterExpressionRestrictionType;
export declare type SortRestrictionsTypeTypes = SortRestrictionsType;
export declare type ExpandRestrictionsTypeTypes = ExpandRestrictionsType;
export declare type SearchRestrictionsTypeTypes = SearchRestrictionsType;
export declare type InsertRestrictionsTypeTypes = InsertRestrictionsType;
export declare type PermissionTypeTypes = PermissionType;
export declare type ScopeTypeTypes = ScopeType;
export declare type DeepInsertSupportTypeTypes = DeepInsertSupportType;
export declare type UpdateRestrictionsTypeTypes = UpdateRestrictionsType;
export declare type DeepUpdateSupportTypeTypes = DeepUpdateSupportType;
export declare type DeleteRestrictionsTypeTypes = DeleteRestrictionsType;
export declare type CollectionPropertyRestrictionsTypeTypes = CollectionPropertyRestrictionsType;
export declare type OperationRestrictionsTypeTypes = OperationRestrictionsType;
export declare type ModificationQueryOptionsTypeTypes = ModificationQueryOptionsType;
export declare type ReadRestrictionsBaseTypes = ReadByKeyRestrictionsTypeTypes | ReadRestrictionsTypeTypes;
export declare type ReadByKeyRestrictionsTypeTypes = ReadByKeyRestrictionsType;
export declare type ReadRestrictionsTypeTypes = ReadRestrictionsType;
export declare type CustomParameterTypes = CustomParameter;

22

vocabularies/CodeList.d.ts

@@ -8,7 +8,11 @@ import * as Edm from "../Edm";

*/
export declare type CurrencyCodes = AnnotationTerm<CodeListSourceTypes>;
export declare type CurrencyCodes = {
term: CodeListAnnotationTerms.CurrencyCodes;
} & AnnotationTerm<CodeListSourceTypes>;
/**
An entity set containing the code list for units of measure
*/
export declare type UnitsOfMeasure = AnnotationTerm<CodeListSourceTypes>;
export declare type UnitsOfMeasure = {
term: CodeListAnnotationTerms.UnitsOfMeasure;
} & AnnotationTerm<CodeListSourceTypes>;
/**

@@ -31,11 +35,17 @@ An entity set containing the code list for currencies

*/
export declare type StandardCode = AnnotationTerm<Edm.PropertyPath>;
export declare type StandardCode = {
term: CodeListAnnotationTerms.StandardCode;
} & AnnotationTerm<Edm.PropertyPath>;
/**
Property containing code values that can be used for visualization
*/
export declare type ExternalCode = AnnotationTerm<Edm.PropertyPath>;
export declare type ExternalCode = {
term: CodeListAnnotationTerms.ExternalCode;
} & AnnotationTerm<Edm.PropertyPath>;
/**
Property contains a Configuration Deprecation Code
*/
export declare type IsConfigurationDeprecationCode = AnnotationTerm<Edm.Boolean>;
export declare type IsConfigurationDeprecationCode = {
term: CodeListAnnotationTerms.IsConfigurationDeprecationCode;
} & AnnotationTerm<Edm.Boolean>;
export declare const enum CodeListAnnotationTerms {

@@ -51,2 +61,2 @@ CurrencyCodes = "com.sap.vocabularies.CodeList.v1.CurrencyCodes",

}
export declare type CodeListSourceTypes = AnnotationTerm<CodeListSource>;
export declare type CodeListSourceTypes = CodeListSource;

444

vocabularies/Common.d.ts

@@ -12,39 +12,59 @@ import * as Core from "./Core";

*/
export declare type Experimental = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Experimental = {
term: CommonAnnotationTerms.Experimental;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
1 for first version of a service, incremented when schema changes incompatibly and service is published with a different URI
*/
export declare type ServiceVersion = AnnotationTerm<Edm.Int32>;
export declare type ServiceVersion = {
term: CommonAnnotationTerms.ServiceVersion;
} & AnnotationTerm<Edm.Int32>;
/**
0 for first schema version within a service version, incremented when schema changes compatibly
*/
export declare type ServiceSchemaVersion = AnnotationTerm<Edm.Int32>;
export declare type ServiceSchemaVersion = {
term: CommonAnnotationTerms.ServiceSchemaVersion;
} & AnnotationTerm<Edm.Int32>;
/**
A short, human-readable text suitable for labels and captions in UIs
*/
export declare type Label = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Label = {
term: CommonAnnotationTerms.Label;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A short, human-readable text suitable for column headings in UIs
*/
export declare type Heading = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Heading = {
term: CommonAnnotationTerms.Heading;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A short, human-readable text suitable for tool tips in UIs
*/
export declare type QuickInfo = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type QuickInfo = {
term: CommonAnnotationTerms.QuickInfo;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A descriptive text for values of the annotated property. Value MUST be a dynamic expression when used as metadata annotation.
*/
export declare type Text = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Text = {
term: CommonAnnotationTerms.Text;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The annotated property contains a descriptive text for values of the referenced property.
*/
export declare type TextFor = AnnotationTerm<Edm.PropertyPath>;
export declare type TextFor = {
term: CommonAnnotationTerms.TextFor;
} & AnnotationTerm<Edm.PropertyPath>;
/**
A human readable identifier for values of the annotated property. Value MUST be a dynamic expression when used as metadata annotation.
*/
export declare type ExternalID = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ExternalID = {
term: CommonAnnotationTerms.ExternalID;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
An identifier to distinguish multiple texts in different languages for the same entity
*/
export declare type IsLanguageIdentifier = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsLanguageIdentifier = {
term: CommonAnnotationTerms.IsLanguageIdentifier;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -73,67 +93,101 @@ The annotated property, parameter, or return type contains human-readable text that may contain formatting information

*/
export declare type Timezone = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Timezone = {
term: CommonAnnotationTerms.Timezone;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Contains only digits
*/
export declare type IsDigitSequence = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsDigitSequence = {
term: CommonAnnotationTerms.IsDigitSequence;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Contains just uppercase characters
*/
export declare type IsUpperCase = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsUpperCase = {
term: CommonAnnotationTerms.IsUpperCase;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Annotated property or parameter is a currency code
*/
export declare type IsCurrency = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCurrency = {
term: CommonAnnotationTerms.IsCurrency;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Annotated property or parameter is a unit of measure
*/
export declare type IsUnit = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsUnit = {
term: CommonAnnotationTerms.IsUnit;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
The number of fractional decimal digits of a currency amount or measured quantity
*/
export declare type UnitSpecificScale = AnnotationTerm<Edm.PrimitiveType>;
export declare type UnitSpecificScale = {
term: CommonAnnotationTerms.UnitSpecificScale;
} & AnnotationTerm<Edm.PrimitiveType>;
/**
The number of significant decimal digits of a currency amount or measured quantity
*/
export declare type UnitSpecificPrecision = AnnotationTerm<Edm.PrimitiveType>;
export declare type UnitSpecificPrecision = {
term: CommonAnnotationTerms.UnitSpecificPrecision;
} & AnnotationTerm<Edm.PrimitiveType>;
/**
The listed properties form a secondary key. Multiple secondary keys are possible using different qualifiers.
*/
export declare type SecondaryKey = AnnotationTerm<Edm.PropertyPath[]>;
export declare type SecondaryKey = {
term: CommonAnnotationTerms.SecondaryKey;
} & AnnotationTerm<Edm.PropertyPath[]>;
/**
The annotated set or collection contains at least this number of items
*/
export declare type MinOccurs = AnnotationTerm<Edm.Int64>;
export declare type MinOccurs = {
term: CommonAnnotationTerms.MinOccurs;
} & AnnotationTerm<Edm.Int64>;
/**
The annotated set or collection contains at most this number of items
*/
export declare type MaxOccurs = AnnotationTerm<Edm.Int64>;
export declare type MaxOccurs = {
term: CommonAnnotationTerms.MaxOccurs;
} & AnnotationTerm<Edm.Int64>;
/**
Entity representing an n:m association with attributes
*/
export declare type AssociationEntity = AnnotationTerm<Edm.NavigationPropertyPath[]>;
export declare type AssociationEntity = {
term: CommonAnnotationTerms.AssociationEntity;
} & AnnotationTerm<Edm.NavigationPropertyPath[]>;
/**
Shortcut for a multi-segment navigation, contains the long path with all its segments
*/
export declare type DerivedNavigation = AnnotationTerm<Edm.NavigationPropertyPath>;
export declare type DerivedNavigation = {
term: CommonAnnotationTerms.DerivedNavigation;
} & AnnotationTerm<Edm.NavigationPropertyPath>;
/**
Property contains sensitive data that should by default be masked on a UI and clear-text visible only upon user interaction
*/
export declare type Masked = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Masked = {
term: CommonAnnotationTerms.Masked;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Property contains sensitive data that is by default not transferred
*/
export declare type MaskedValue = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type MaskedValue = {
term: CommonAnnotationTerms.MaskedValue;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Unmasked data for this property can be requested with custom query option `masked-values=false`
*/
export declare type RevealOnDemand = AnnotationTerm<Edm.Boolean>;
export declare type RevealOnDemand = {
term: CommonAnnotationTerms.RevealOnDemand;
} & AnnotationTerm<Edm.Boolean>;
/**
Name of the Semantic Object represented as this entity type or identified by this property
*/
export declare type SemanticObject = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type SemanticObject = {
term: CommonAnnotationTerms.SemanticObject;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Maps properties of the annotated entity type or sibling properties of the annotated property to properties of the Semantic Object
*/
export declare type SemanticObjectMapping = AnnotationTerm<SemanticObjectMappingTypeTypes[]>;
export declare type SemanticObjectMapping = {
term: CommonAnnotationTerms.SemanticObjectMapping;
} & AnnotationTerm<SemanticObjectMappingTypeTypes[]>;
/**

@@ -156,11 +210,17 @@ Maps a property of the annotated entity type or a sibling property of the annotated property to a property of the Semantic Object

*/
export declare type SemanticObjectUnavailableActions = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type SemanticObjectUnavailableActions = {
term: CommonAnnotationTerms.SemanticObjectUnavailableActions;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
Term can also be used as instance annotation; AppliesTo of this term specifies where it can be applied
*/
export declare type IsInstanceAnnotation = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsInstanceAnnotation = {
term: CommonAnnotationTerms.IsInstanceAnnotation;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
These properties only allow a subset of expressions
*/
export declare type FilterExpressionRestrictions = AnnotationTerm<FilterExpressionRestrictionTypeTypes[]>;
export declare type FilterExpressionRestrictions = {
term: CommonAnnotationTerms.FilterExpressionRestrictions;
} & AnnotationTerm<FilterExpressionRestrictionTypeTypes[]>;
export declare type FilterExpressionRestrictionType = ComplexType & {

@@ -243,7 +303,11 @@ $Type: CommonAnnotationTypes.FilterExpressionRestrictionType;

*/
export declare type ExceptionCategory = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ExceptionCategory = {
term: CommonAnnotationTerms.ExceptionCategory;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
...
*/
export declare type Application = AnnotationTerm<ApplicationTypeTypes>;
export declare type Application = {
term: CommonAnnotationTerms.Application;
} & AnnotationTerm<ApplicationTypeTypes>;
export declare type ApplicationType = ComplexType & {

@@ -271,11 +335,17 @@ $Type: CommonAnnotationTypes.ApplicationType;

*/
export declare type Timestamp = AnnotationTerm<Edm.DateTimeOffset>;
export declare type Timestamp = {
term: CommonAnnotationTerms.Timestamp;
} & AnnotationTerm<Edm.DateTimeOffset>;
/**
...
*/
export declare type TransactionId = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type TransactionId = {
term: CommonAnnotationTerms.TransactionId;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Hints for resolving this error
*/
export declare type ErrorResolution = AnnotationTerm<ErrorResolutionTypeTypes>;
export declare type ErrorResolution = {
term: CommonAnnotationTerms.ErrorResolution;
} & AnnotationTerm<ErrorResolutionTypeTypes>;
export declare type ErrorResolutionType = ComplexType & {

@@ -299,19 +369,29 @@ $Type: CommonAnnotationTypes.ErrorResolutionType;

*/
export declare type Messages = AnnotationTerm<Edm.ComplexType[]>;
export declare type Messages = {
term: CommonAnnotationTerms.Messages;
} & AnnotationTerm<Edm.ComplexType[]>;
/**
Additional targets for the message
*/
export declare type additionalTargets = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type additionalTargets = {
term: CommonAnnotationTerms.additionalTargets;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
Location of the message long text
*/
export declare type longtextUrl = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type longtextUrl = {
term: CommonAnnotationTerms.longtextUrl;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Classifies an end-user message as info, success, warning, or error
*/
export declare type numericSeverity = AnnotationTerm<PropertyAnnotationValue<NumericMessageSeverityType>>;
export declare type numericSeverity = {
term: CommonAnnotationTerms.numericSeverity;
} & AnnotationTerm<PropertyAnnotationValue<NumericMessageSeverityType>>;
/**
The maximum severity of all end-user messages attached to an entity, null if no messages are attached
*/
export declare type MaximumNumericMessageSeverity = AnnotationTerm<PropertyAnnotationValue<NumericMessageSeverityType>>;
export declare type MaximumNumericMessageSeverity = {
term: CommonAnnotationTerms.MaximumNumericMessageSeverity;
} & AnnotationTerm<PropertyAnnotationValue<NumericMessageSeverityType>>;
/**

@@ -324,15 +404,23 @@ Classifies an end-user message as info, success, warning, or error

*/
export declare type IsActionCritical = AnnotationTerm<Edm.Boolean>;
export declare type IsActionCritical = {
term: CommonAnnotationTerms.IsActionCritical;
} & AnnotationTerm<Edm.Boolean>;
/**
Attributes related to this property, which may occur in denormalized entity types
*/
export declare type Attributes = AnnotationTerm<Edm.PropertyPath[]>;
export declare type Attributes = {
term: CommonAnnotationTerms.Attributes;
} & AnnotationTerm<Edm.PropertyPath[]>;
/**
A recursive hierarchy related to this property. The annotation path must end in Aggregation.RecursiveHierarchy.
*/
export declare type RelatedRecursiveHierarchy = AnnotationTerm<Edm.AnnotationPath<any>>;
export declare type RelatedRecursiveHierarchy = {
term: CommonAnnotationTerms.RelatedRecursiveHierarchy;
} & AnnotationTerm<Edm.AnnotationPath<any>>;
/**
An interval with lower and upper boundaries described by two properties
*/
export declare type Interval = AnnotationTerm<IntervalTypeTypes>;
export declare type Interval = {
term: CommonAnnotationTerms.Interval;
} & AnnotationTerm<IntervalTypeTypes>;
export declare type IntervalType = ComplexType & {

@@ -362,7 +450,11 @@ $Type: CommonAnnotationTypes.IntervalType;

*/
export declare type ResultContext = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type ResultContext = {
term: CommonAnnotationTerms.ResultContext;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
The SAP Object Node Type represented by the annotated entity type
*/
export declare type SAPObjectNodeType = AnnotationTerm<SAPObjectNodeTypeTypeTypes>;
export declare type SAPObjectNodeType = {
term: CommonAnnotationTerms.SAPObjectNodeType;
} & AnnotationTerm<SAPObjectNodeTypeTypeTypes>;
/**

@@ -381,15 +473,23 @@ Information about an SAP Object Node Type

*/
export declare type Composition = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Composition = {
term: CommonAnnotationTerms.Composition;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
The name of the SAP Object Node Type referenced by the annotated property
*/
export declare type SAPObjectNodeTypeReference = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type SAPObjectNodeTypeReference = {
term: CommonAnnotationTerms.SAPObjectNodeTypeReference;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The annotated entity type (e.g. `Employee`) or annotation (e.g. `IsImageUrl`) represents a natural person
*/
export declare type IsNaturalPerson = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsNaturalPerson = {
term: CommonAnnotationTerms.IsNaturalPerson;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Specifies how to get a list of acceptable values for a property or parameter
*/
export declare type ValueList = AnnotationTerm<ValueListTypeTypes>;
export declare type ValueList = {
term: CommonAnnotationTerms.ValueList;
} & AnnotationTerm<ValueListTypeTypes>;
export declare type ValueListType = ComplexType & {

@@ -432,3 +532,3 @@ $Type: CommonAnnotationTypes.ValueListType;

*/
Parameters: AnnotationTerm<ValueListParameterTypes[]>;
Parameters: ValueListParameterTypes[];
};

@@ -442,19 +542,29 @@ /**

*/
export declare type ValueListRelevantQualifiers = AnnotationTerm<PropertyAnnotationValue<SimpleIdentifier[]>>;
export declare type ValueListRelevantQualifiers = {
term: CommonAnnotationTerms.ValueListRelevantQualifiers;
} & AnnotationTerm<PropertyAnnotationValue<SimpleIdentifier[]>>;
/**
If specified as true, there's only one value list mapping and its value list consists of a small number of fixed values
*/
export declare type ValueListWithFixedValues = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type ValueListWithFixedValues = {
term: CommonAnnotationTerms.ValueListWithFixedValues;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Contains the qualifier of the ValueList or ValueListMapping that should be used for validation
*/
export declare type ValueListForValidation = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ValueListForValidation = {
term: CommonAnnotationTerms.ValueListForValidation;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A list of URLs of CSDL documents containing value list mappings for this parameter or property
*/
export declare type ValueListReferences = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type ValueListReferences = {
term: CommonAnnotationTerms.ValueListReferences;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
Specifies the mapping between data service properties and value list properties
*/
export declare type ValueListMapping = AnnotationTerm<ValueListMappingTypeTypes>;
export declare type ValueListMapping = {
term: CommonAnnotationTerms.ValueListMapping;
} & AnnotationTerm<ValueListMappingTypeTypes>;
export declare type ValueListMappingType = ComplexType & {

@@ -489,3 +599,3 @@ $Type: CommonAnnotationTypes.ValueListMappingType;

*/
Parameters: AnnotationTerm<ValueListParameterTypes[]>;
Parameters: ValueListParameterTypes[];
};

@@ -552,3 +662,5 @@ export declare type ValueListParameter = ComplexType & {

*/
export declare type IsCalendarYear = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarYear = {
term: CommonAnnotationTerms.IsCalendarYear;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -559,3 +671,5 @@ Property encodes a halfyear number as string following the logical pattern H consisting of a single digit.

*/
export declare type IsCalendarHalfyear = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarHalfyear = {
term: CommonAnnotationTerms.IsCalendarHalfyear;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -566,3 +680,5 @@ Property encodes a calendar quarter number as string following the logical pattern Q consisting of a single digit.

*/
export declare type IsCalendarQuarter = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarQuarter = {
term: CommonAnnotationTerms.IsCalendarQuarter;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -573,3 +689,5 @@ Property encodes a calendar month number as string following the logical pattern MM consisting of two digits.

*/
export declare type IsCalendarMonth = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarMonth = {
term: CommonAnnotationTerms.IsCalendarMonth;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -580,3 +698,5 @@ Property encodes a calendar week number as string following the logical pattern WW consisting of two digits.

*/
export declare type IsCalendarWeek = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarWeek = {
term: CommonAnnotationTerms.IsCalendarWeek;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -586,3 +706,5 @@ Day number relative to a calendar month. Valid values are between 1 and 31.

*/
export declare type IsDayOfCalendarMonth = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsDayOfCalendarMonth = {
term: CommonAnnotationTerms.IsDayOfCalendarMonth;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -592,3 +714,5 @@ Day number relative to a calendar year. Valid values are between 1 and 366.

*/
export declare type IsDayOfCalendarYear = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsDayOfCalendarYear = {
term: CommonAnnotationTerms.IsDayOfCalendarYear;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -600,3 +724,5 @@ Property encodes a calendar year and halfyear as string following the logical pattern (-?)YYYY(Y*)H consisting

*/
export declare type IsCalendarYearHalfyear = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarYearHalfyear = {
term: CommonAnnotationTerms.IsCalendarYearHalfyear;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -608,3 +734,5 @@ Property encodes a calendar year and quarter as string following the logical pattern (-?)YYYY(Y*)Q consisting

*/
export declare type IsCalendarYearQuarter = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarYearQuarter = {
term: CommonAnnotationTerms.IsCalendarYearQuarter;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -617,3 +745,5 @@ Property encodes a calendar year and month as string following the logical pattern (-?)YYYY(Y*)MM consisting

*/
export declare type IsCalendarYearMonth = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarYearMonth = {
term: CommonAnnotationTerms.IsCalendarYearMonth;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -625,3 +755,5 @@ Property encodes a calendar year and week as string following the logical pattern (-?)YYYY(Y*)WW consisting

*/
export declare type IsCalendarYearWeek = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarYearWeek = {
term: CommonAnnotationTerms.IsCalendarYearWeek;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -637,3 +769,5 @@ Property encodes a calendar date: year, month and day as string following the logical pattern (-?)YYYY(Y*)MMDD consisting

*/
export declare type IsCalendarDate = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsCalendarDate = {
term: CommonAnnotationTerms.IsCalendarDate;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -644,3 +778,5 @@ Property encodes a fiscal year number as string following the logical pattern YYYY consisting of four digits.

*/
export declare type IsFiscalYear = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalYear = {
term: CommonAnnotationTerms.IsFiscalYear;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -651,3 +787,5 @@ Property encodes a fiscal period as string following the logical pattern PPP consisting of three digits.

*/
export declare type IsFiscalPeriod = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalPeriod = {
term: CommonAnnotationTerms.IsFiscalPeriod;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -659,3 +797,5 @@ Property encodes a fiscal year and period as string following the logical pattern YYYYPPP consisting

*/
export declare type IsFiscalYearPeriod = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalYearPeriod = {
term: CommonAnnotationTerms.IsFiscalYearPeriod;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -665,3 +805,5 @@ Property encodes a fiscal quarter number as string following the logical pattern Q consisting of a single digit.

*/
export declare type IsFiscalQuarter = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalQuarter = {
term: CommonAnnotationTerms.IsFiscalQuarter;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -672,3 +814,5 @@ Property encodes a fiscal year and quarter as string following the logical pattern YYYYQ consisting of

*/
export declare type IsFiscalYearQuarter = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalYearQuarter = {
term: CommonAnnotationTerms.IsFiscalYearQuarter;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -678,3 +822,5 @@ Property encodes a fiscal week number as string following the logical pattern WW consisting of two digits.

*/
export declare type IsFiscalWeek = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalWeek = {
term: CommonAnnotationTerms.IsFiscalWeek;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**

@@ -685,19 +831,29 @@ Property encodes a fiscal year and week as string following the logical pattern YYYYWW consisting of

*/
export declare type IsFiscalYearWeek = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalYearWeek = {
term: CommonAnnotationTerms.IsFiscalYearWeek;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Day number relative to a fiscal year. Valid values are between 1 and 371.
*/
export declare type IsDayOfFiscalYear = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsDayOfFiscalYear = {
term: CommonAnnotationTerms.IsDayOfFiscalYear;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Property encodes a fiscal year variant
*/
export declare type IsFiscalYearVariant = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsFiscalYearVariant = {
term: CommonAnnotationTerms.IsFiscalYearVariant;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Only one term of the group identified with the Qualifier attribute can be applied
*/
export declare type MutuallyExclusiveTerm = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type MutuallyExclusiveTerm = {
term: CommonAnnotationTerms.MutuallyExclusiveTerm;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Root entities of business documents that support the draft pattern
*/
export declare type DraftRoot = AnnotationTerm<DraftRootTypeTypes>;
export declare type DraftRoot = {
term: CommonAnnotationTerms.DraftRoot;
} & AnnotationTerm<DraftRootTypeTypes>;
export declare type DraftRootType = ComplexType & Omit<DraftNodeType, '$Type'> & {

@@ -733,3 +889,5 @@ $Type: CommonAnnotationTypes.DraftRootType;

*/
export declare type DraftNode = AnnotationTerm<DraftNodeTypeTypes>;
export declare type DraftNode = {
term: CommonAnnotationTerms.DraftNode;
} & AnnotationTerm<DraftNodeTypeTypes>;
export declare type DraftNodeType = ComplexType & {

@@ -749,7 +907,11 @@ $Type: CommonAnnotationTypes.DraftNodeType;

*/
export declare type DraftActivationVia = AnnotationTerm<PropertyAnnotationValue<SimpleIdentifier[]>>;
export declare type DraftActivationVia = {
term: CommonAnnotationTerms.DraftActivationVia;
} & AnnotationTerm<PropertyAnnotationValue<SimpleIdentifier[]>>;
/**
The annotated property is an editable field for the referenced key property
*/
export declare type EditableFieldFor = AnnotationTerm<Edm.PropertyPath>;
export declare type EditableFieldFor = {
term: CommonAnnotationTerms.EditableFieldFor;
} & AnnotationTerm<Edm.PropertyPath>;
/**

@@ -770,7 +932,11 @@ The SimpleIdentifier of an OData construct in scope

*/
export declare type SemanticKey = AnnotationTerm<Edm.PropertyPath[]>;
export declare type SemanticKey = {
term: CommonAnnotationTerms.SemanticKey;
} & AnnotationTerm<Edm.PropertyPath[]>;
/**
Describes side-effects of modification operations
*/
export declare type SideEffects = AnnotationTerm<SideEffectsTypeTypes>;
export declare type SideEffects = {
term: CommonAnnotationTerms.SideEffects;
} & AnnotationTerm<SideEffectsTypeTypes>;
/**

@@ -788,3 +954,3 @@ Changes to the source properties or source entities may have side-effects on the target properties or entities.

*/
SourceEntities: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
SourceEntities: Edm.NavigationPropertyPath[];
/**

@@ -797,3 +963,3 @@ These structural properties may be affected if the value of one of the sources changes

*/
TargetEntities: PropertyAnnotationValue<Edm.NavigationPropertyPath[]>;
TargetEntities: Edm.NavigationPropertyPath[];
/**

@@ -846,23 +1012,35 @@ One or more of the targets may show these effects. If not specified, any effect is possible.

*/
export declare type DefaultValuesFunction = AnnotationTerm<PropertyAnnotationValue<QualifiedName>>;
export declare type DefaultValuesFunction = {
term: CommonAnnotationTerms.DefaultValuesFunction;
} & AnnotationTerm<PropertyAnnotationValue<QualifiedName>>;
/**
Function import to derive a default value for the property from a given context.
*/
export declare type DerivedDefaultValue = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type DerivedDefaultValue = {
term: CommonAnnotationTerms.DerivedDefaultValue;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A default value for the property to be used in filter expressions.
*/
export declare type FilterDefaultValue = AnnotationTerm<Edm.PrimitiveType>;
export declare type FilterDefaultValue = {
term: CommonAnnotationTerms.FilterDefaultValue;
} & AnnotationTerm<Edm.PrimitiveType>;
/**
A default upper limit for the property to be used in 'less than or equal' filter expressions.
*/
export declare type FilterDefaultValueHigh = AnnotationTerm<Edm.PrimitiveType>;
export declare type FilterDefaultValueHigh = {
term: CommonAnnotationTerms.FilterDefaultValueHigh;
} & AnnotationTerm<Edm.PrimitiveType>;
/**
Function import to derive a default value for the property from a given context in order to use it in filter expressions.
*/
export declare type DerivedFilterDefaultValue = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type DerivedFilterDefaultValue = {
term: CommonAnnotationTerms.DerivedFilterDefaultValue;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
List of sort criteria
*/
export declare type SortOrder = AnnotationTerm<SortOrderTypeTypes[]>;
export declare type SortOrder = {
term: CommonAnnotationTerms.SortOrder;
} & AnnotationTerm<SortOrderTypeTypes[]>;
/**

@@ -889,3 +1067,5 @@ Exactly one of `Property` and `DynamicProperty` must be present

*/
export declare type RecursiveHierarchy = AnnotationTerm<RecursiveHierarchyTypeTypes>;
export declare type RecursiveHierarchy = {
term: CommonAnnotationTerms.RecursiveHierarchy;
} & AnnotationTerm<RecursiveHierarchyTypeTypes>;
export declare type RecursiveHierarchyType = ComplexType & {

@@ -917,15 +1097,23 @@ $Type: CommonAnnotationTypes.RecursiveHierarchyType;

*/
export declare type CreatedAt = AnnotationTerm<Edm.DateTimeOffset>;
export declare type CreatedAt = {
term: CommonAnnotationTerms.CreatedAt;
} & AnnotationTerm<Edm.DateTimeOffset>;
/**
First editor
*/
export declare type CreatedBy = AnnotationTerm<PropertyAnnotationValue<UserID>>;
export declare type CreatedBy = {
term: CommonAnnotationTerms.CreatedBy;
} & AnnotationTerm<PropertyAnnotationValue<UserID>>;
/**
Last modification timestamp
*/
export declare type ChangedAt = AnnotationTerm<Edm.DateTimeOffset>;
export declare type ChangedAt = {
term: CommonAnnotationTerms.ChangedAt;
} & AnnotationTerm<Edm.DateTimeOffset>;
/**
Last editor
*/
export declare type ChangedBy = AnnotationTerm<PropertyAnnotationValue<UserID>>;
export declare type ChangedBy = {
term: CommonAnnotationTerms.ChangedBy;
} & AnnotationTerm<PropertyAnnotationValue<UserID>>;
/**

@@ -938,19 +1126,29 @@ User ID

*/
export declare type OriginalProtocolVersion = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type OriginalProtocolVersion = {
term: CommonAnnotationTerms.OriginalProtocolVersion;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Sorting and filtering of amounts in multiple currencies needs special consideration
*/
export declare type ApplyMultiUnitBehaviorForSortingAndFiltering = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type ApplyMultiUnitBehaviorForSortingAndFiltering = {
term: CommonAnnotationTerms.ApplyMultiUnitBehaviorForSortingAndFiltering;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
URL for uploading new media content to a Document Management Service
*/
export declare type mediaUploadLink = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type mediaUploadLink = {
term: CommonAnnotationTerms.mediaUploadLink;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A term or term property with this tag whose type is (a collection of) `Edm.PropertyPath` MUST resolve to a primitive structural property
*/
export declare type PrimitivePropertyPath = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type PrimitivePropertyPath = {
term: CommonAnnotationTerms.PrimitivePropertyPath;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Base URL for WebSocket connections
*/
export declare type WebSocketBaseURL = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type WebSocketBaseURL = {
term: CommonAnnotationTerms.WebSocketBaseURL;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare const enum CommonAnnotationTerms {

@@ -1081,21 +1279,21 @@ Experimental = "com.sap.vocabularies.Common.v1.Experimental",

}
export declare type SemanticObjectMappingTypeTypes = AnnotationTerm<SemanticObjectMappingType>;
export declare type FilterExpressionRestrictionTypeTypes = AnnotationTerm<FilterExpressionRestrictionType>;
export declare type ApplicationTypeTypes = AnnotationTerm<ApplicationType>;
export declare type ErrorResolutionTypeTypes = AnnotationTerm<ErrorResolutionType>;
export declare type IntervalTypeTypes = AnnotationTerm<IntervalType>;
export declare type SAPObjectNodeTypeTypeTypes = AnnotationTerm<SAPObjectNodeTypeType>;
export declare type ValueListTypeTypes = AnnotationTerm<ValueListType>;
export declare type ValueListMappingTypeTypes = AnnotationTerm<ValueListMappingType>;
export declare type ValueListParameterTypes = AnnotationTerm<ValueListParameterInTypes | ValueListParameterConstantTypes | ValueListParameterInOutTypes | ValueListParameterOutTypes | ValueListParameterDisplayOnlyTypes | ValueListParameterFilterOnlyTypes>;
export declare type ValueListParameterInTypes = AnnotationTerm<ValueListParameterIn>;
export declare type ValueListParameterConstantTypes = AnnotationTerm<ValueListParameterConstant>;
export declare type ValueListParameterInOutTypes = AnnotationTerm<ValueListParameterInOut>;
export declare type ValueListParameterOutTypes = AnnotationTerm<ValueListParameterOut>;
export declare type ValueListParameterDisplayOnlyTypes = AnnotationTerm<ValueListParameterDisplayOnly>;
export declare type ValueListParameterFilterOnlyTypes = AnnotationTerm<ValueListParameterFilterOnly>;
export declare type DraftRootTypeTypes = AnnotationTerm<DraftRootType>;
export declare type DraftNodeTypeTypes = AnnotationTerm<DraftNodeType | DraftRootTypeTypes>;
export declare type SideEffectsTypeTypes = AnnotationTerm<SideEffectsType>;
export declare type SortOrderTypeTypes = AnnotationTerm<SortOrderType>;
export declare type RecursiveHierarchyTypeTypes = AnnotationTerm<RecursiveHierarchyType>;
export declare type SemanticObjectMappingTypeTypes = SemanticObjectMappingType;
export declare type FilterExpressionRestrictionTypeTypes = FilterExpressionRestrictionType;
export declare type ApplicationTypeTypes = ApplicationType;
export declare type ErrorResolutionTypeTypes = ErrorResolutionType;
export declare type IntervalTypeTypes = IntervalType;
export declare type SAPObjectNodeTypeTypeTypes = SAPObjectNodeTypeType;
export declare type ValueListTypeTypes = ValueListType;
export declare type ValueListMappingTypeTypes = ValueListMappingType;
export declare type ValueListParameterTypes = ValueListParameterInTypes | ValueListParameterConstantTypes | ValueListParameterInOutTypes | ValueListParameterOutTypes | ValueListParameterDisplayOnlyTypes | ValueListParameterFilterOnlyTypes;
export declare type ValueListParameterInTypes = ValueListParameterIn;
export declare type ValueListParameterConstantTypes = ValueListParameterConstant;
export declare type ValueListParameterInOutTypes = ValueListParameterInOut;
export declare type ValueListParameterOutTypes = ValueListParameterOut;
export declare type ValueListParameterDisplayOnlyTypes = ValueListParameterDisplayOnly;
export declare type ValueListParameterFilterOnlyTypes = ValueListParameterFilterOnly;
export declare type DraftRootTypeTypes = DraftRootType;
export declare type DraftNodeTypeTypes = DraftNodeType | DraftRootTypeTypes;
export declare type SideEffectsTypeTypes = SideEffectsType;
export declare type SortOrderTypeTypes = SortOrderType;
export declare type RecursiveHierarchyTypeTypes = RecursiveHierarchyType;

60

vocabularies/Communication.d.ts

@@ -9,3 +9,5 @@ import * as Core from "./Core";

*/
export declare type Contact = AnnotationTerm<ContactTypeTypes>;
export declare type Contact = {
term: CommunicationAnnotationTerms.Contact;
} & AnnotationTerm<ContactTypeTypes>;
export declare type ContactType = ComplexType & {

@@ -20,3 +22,3 @@ $Type: CommunicationAnnotationTypes.ContactType;

*/
n?: AnnotationTerm<NameTypeTypes>;
n?: NameTypeTypes;
/**

@@ -69,19 +71,19 @@ Nickname

*/
adr: AnnotationTerm<AddressTypeTypes[]>;
adr: AddressTypeTypes[];
/**
Phone numbers
*/
tel: AnnotationTerm<PhoneNumberTypeTypes[]>;
tel: PhoneNumberTypeTypes[];
/**
Email addresses
*/
email: AnnotationTerm<EmailAddressTypeTypes[]>;
email: EmailAddressTypeTypes[];
/**
Geographic locations
*/
geo: AnnotationTerm<GeoDataTypeTypes[]>;
geo: GeoDataTypeTypes[];
/**
URLs
*/
url: AnnotationTerm<UrlTypeTypes[]>;
url: UrlTypeTypes[];
};

@@ -114,3 +116,5 @@ export declare type NameType = ComplexType & {

*/
export declare type Address = AnnotationTerm<AddressTypeTypes>;
export declare type Address = {
term: CommunicationAnnotationTerms.Address;
} & AnnotationTerm<AddressTypeTypes>;
export declare type AddressType = ComplexType & {

@@ -355,11 +359,17 @@ $Type: CommunicationAnnotationTypes.AddressType;

*/
export declare type IsEmailAddress = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsEmailAddress = {
term: CommunicationAnnotationTerms.IsEmailAddress;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Property contains a phone number
*/
export declare type IsPhoneNumber = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsPhoneNumber = {
term: CommunicationAnnotationTerms.IsPhoneNumber;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Calendar entry
*/
export declare type Event = AnnotationTerm<EventDataTypes>;
export declare type Event = {
term: CommunicationAnnotationTerms.Event;
} & AnnotationTerm<EventDataTypes>;
export declare type EventData = ComplexType & {

@@ -419,3 +429,5 @@ $Type: CommunicationAnnotationTypes.EventData;

*/
export declare type Task = AnnotationTerm<TaskDataTypes>;
export declare type Task = {
term: CommunicationAnnotationTerms.Task;
} & AnnotationTerm<TaskDataTypes>;
export declare type TaskData = ComplexType & {

@@ -451,3 +463,5 @@ $Type: CommunicationAnnotationTypes.TaskData;

*/
export declare type Message = AnnotationTerm<MessageDataTypes>;
export declare type Message = {
term: CommunicationAnnotationTerms.Message;
} & AnnotationTerm<MessageDataTypes>;
export declare type MessageData = ComplexType & {

@@ -513,11 +527,11 @@ $Type: CommunicationAnnotationTypes.MessageData;

}
export declare type ContactTypeTypes = AnnotationTerm<ContactType>;
export declare type NameTypeTypes = AnnotationTerm<NameType>;
export declare type AddressTypeTypes = AnnotationTerm<AddressType>;
export declare type PhoneNumberTypeTypes = AnnotationTerm<PhoneNumberType>;
export declare type EmailAddressTypeTypes = AnnotationTerm<EmailAddressType>;
export declare type GeoDataTypeTypes = AnnotationTerm<GeoDataType>;
export declare type UrlTypeTypes = AnnotationTerm<UrlType>;
export declare type EventDataTypes = AnnotationTerm<EventData>;
export declare type TaskDataTypes = AnnotationTerm<TaskData>;
export declare type MessageDataTypes = AnnotationTerm<MessageData>;
export declare type ContactTypeTypes = ContactType;
export declare type NameTypeTypes = NameType;
export declare type AddressTypeTypes = AddressType;
export declare type PhoneNumberTypeTypes = PhoneNumberType;
export declare type EmailAddressTypeTypes = EmailAddressType;
export declare type GeoDataTypeTypes = GeoDataType;
export declare type UrlTypeTypes = UrlType;
export declare type EventDataTypes = EventData;
export declare type TaskDataTypes = TaskData;
export declare type MessageDataTypes = MessageData;

200

vocabularies/Core.d.ts

@@ -9,11 +9,17 @@ import * as Edm from "../Edm";

*/
export declare type ODataVersions = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ODataVersions = {
term: CoreAnnotationTerms.ODataVersions;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Service-defined value representing the version of the schema. Services MAY use semantic versioning, but clients MUST NOT assume this is the case.
*/
export declare type SchemaVersion = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type SchemaVersion = {
term: CoreAnnotationTerms.SchemaVersion;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
List of revisions of a model element
*/
export declare type Revisions = AnnotationTerm<RevisionTypeTypes[]>;
export declare type Revisions = {
term: CoreAnnotationTerms.Revisions;
} & AnnotationTerm<RevisionTypeTypes[]>;
export declare type RevisionType = ComplexType & {

@@ -60,11 +66,17 @@ $Type: CoreAnnotationTypes.RevisionType;

*/
export declare type Description = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Description = {
term: CoreAnnotationTerms.Description;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
A long description of a model element
*/
export declare type LongDescription = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type LongDescription = {
term: CoreAnnotationTerms.LongDescription;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Link to related information
*/
export declare type Links = AnnotationTerm<LinkTypes[]>;
export declare type Links = {
term: CoreAnnotationTerms.Links;
} & AnnotationTerm<LinkTypes[]>;
/**

@@ -87,3 +99,5 @@ The Link term is inspired by the `atom:link` element, see [RFC4287](https://tools.ietf.org/html/rfc4287#section-4.2.7), and the `Link` HTTP header, see [RFC5988](https://tools.ietf.org/html/rfc5988)

*/
export declare type Example = AnnotationTerm<ExampleValueTypes>;
export declare type Example = {
term: CoreAnnotationTerms.Example;
} & AnnotationTerm<ExampleValueTypes>;
export declare type ExampleValue = ComplexType & {

@@ -127,3 +141,5 @@ $Type: CoreAnnotationTypes.ExampleValue;

*/
export declare type Messages = AnnotationTerm<MessageTypeTypes[]>;
export declare type Messages = {
term: CoreAnnotationTerms.Messages;
} & AnnotationTerm<MessageTypeTypes[]>;
export declare type MessageType = ComplexType & {

@@ -150,3 +166,3 @@ $Type: CoreAnnotationTypes.MessageType;

*/
details: AnnotationTerm<MessageTypeTypes[]>;
details: MessageTypeTypes[];
};

@@ -157,3 +173,5 @@ export declare type MessageSeverity = Edm.String;

*/
export declare type ValueException = AnnotationTerm<ValueExceptionTypeTypes>;
export declare type ValueException = {
term: CoreAnnotationTerms.ValueException;
} & AnnotationTerm<ValueExceptionTypeTypes>;
export declare type ExceptionType = ComplexType & {

@@ -164,3 +182,3 @@ $Type: CoreAnnotationTypes.ExceptionType;

*/
info?: AnnotationTerm<MessageTypeTypes>;
info?: MessageTypeTypes;
};

@@ -177,3 +195,5 @@ export declare type ValueExceptionType = ComplexType & Omit<ExceptionType, '$Type'> & {

*/
export declare type ResourceException = AnnotationTerm<ResourceExceptionTypeTypes>;
export declare type ResourceException = {
term: CoreAnnotationTerms.ResourceException;
} & AnnotationTerm<ResourceExceptionTypeTypes>;
export declare type ResourceExceptionType = ComplexType & Omit<ExceptionType, '$Type'> & {

@@ -189,3 +209,5 @@ $Type: CoreAnnotationTypes.ResourceExceptionType;

*/
export declare type DataModificationException = AnnotationTerm<DataModificationExceptionTypeTypes>;
export declare type DataModificationException = {
term: CoreAnnotationTerms.DataModificationException;
} & AnnotationTerm<DataModificationExceptionTypeTypes>;
export declare type DataModificationExceptionType = ComplexType & Omit<ExceptionType, '$Type'> & {

@@ -256,3 +278,5 @@ $Type: CoreAnnotationTypes.DataModificationExceptionType;

*/
export declare type IsLanguageDependent = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type IsLanguageDependent = {
term: CoreAnnotationTerms.IsLanguageDependent;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**

@@ -265,19 +289,29 @@ This is the type to use for all tagging terms

*/
export declare type RequiresType = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type RequiresType = {
term: CoreAnnotationTerms.RequiresType;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The target path of an annotation with the tagged term MUST start with an entity container or the annotation MUST be embedded within an entity container, entity set or singleton
*/
export declare type AppliesViaContainer = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type AppliesViaContainer = {
term: CoreAnnotationTerms.AppliesViaContainer;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
Resource path for entity container child, can be relative to xml:base and the request URL
*/
export declare type ResourcePath = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ResourcePath = {
term: CoreAnnotationTerms.ResourcePath;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Entity-ids are URLs that locate the identified entity
*/
export declare type DereferenceableIDs = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type DereferenceableIDs = {
term: CoreAnnotationTerms.DereferenceableIDs;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
Entity-ids follow OData URL conventions
*/
export declare type ConventionalIDs = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type ConventionalIDs = {
term: CoreAnnotationTerms.ConventionalIDs;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**

@@ -327,39 +361,59 @@ Permissions for accessing a resource

*/
export declare type ContentID = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ContentID = {
term: CoreAnnotationTerms.ContentID;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Functions, actions and types in this namespace can be referenced in URLs with or without namespace- or alias- qualification.
*/
export declare type DefaultNamespace = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type DefaultNamespace = {
term: CoreAnnotationTerms.DefaultNamespace;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
A value for this non-key property can be provided by the client on insert and remains unchanged on update
*/
export declare type Immutable = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type Immutable = {
term: CoreAnnotationTerms.Immutable;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
A value for this property is generated on both insert and update
*/
export declare type Computed = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type Computed = {
term: CoreAnnotationTerms.Computed;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
A value for this property can be provided by the client on insert and update. If no value is provided on insert, a non-static default value is generated
*/
export declare type ComputedDefaultValue = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type ComputedDefaultValue = {
term: CoreAnnotationTerms.ComputedDefaultValue;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
Properties and terms annotated with this term MUST contain a valid URL
*/
export declare type IsURL = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type IsURL = {
term: CoreAnnotationTerms.IsURL;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
Lists the MIME types acceptable for the annotated entity type marked with HasStream="true" or the annotated binary, stream, or string property or term
*/
export declare type AcceptableMediaTypes = AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
export declare type AcceptableMediaTypes = {
term: CoreAnnotationTerms.AcceptableMediaTypes;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String[]>>;
/**
The media type of the media stream of the annotated entity type marked with HasStream="true" or the annotated binary, stream, or string property or term
*/
export declare type MediaType = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type MediaType = {
term: CoreAnnotationTerms.MediaType;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Properties and terms annotated with this term MUST contain a valid MIME type
*/
export declare type IsMediaType = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type IsMediaType = {
term: CoreAnnotationTerms.IsMediaType;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
The content disposition of the media stream of the annotated entity type marked with HasStream="true" or the annotated binary, stream, or string property or term
*/
export declare type ContentDisposition = AnnotationTerm<ContentDispositionTypeTypes>;
export declare type ContentDisposition = {
term: CoreAnnotationTerms.ContentDisposition;
} & AnnotationTerm<ContentDispositionTypeTypes>;
export declare type ContentDispositionType = ComplexType & {

@@ -379,19 +433,29 @@ $Type: CoreAnnotationTypes.ContentDispositionType;

*/
export declare type OptimisticConcurrency = AnnotationTerm<Edm.PropertyPath[]>;
export declare type OptimisticConcurrency = {
term: CoreAnnotationTerms.OptimisticConcurrency;
} & AnnotationTerm<Edm.PropertyPath[]>;
/**
Instances of this type may contain properties in addition to those declared in $metadata
*/
export declare type AdditionalProperties = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type AdditionalProperties = {
term: CoreAnnotationTerms.AdditionalProperties;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
The service will automatically expand this stream property, navigation property, or the media stream of this media entity type even if not requested with $expand
*/
export declare type AutoExpand = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type AutoExpand = {
term: CoreAnnotationTerms.AutoExpand;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
The service will automatically expand this navigation property as entity references even if not requested with $expand=.../$ref
*/
export declare type AutoExpandReferences = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type AutoExpandReferences = {
term: CoreAnnotationTerms.AutoExpandReferences;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
A collection of qualified type names outside of the type hierarchy that instances of this type might be addressable as by using a type-cast segment.
*/
export declare type MayImplement = AnnotationTerm<PropertyAnnotationValue<QualifiedTypeName[]>>;
export declare type MayImplement = {
term: CoreAnnotationTerms.MayImplement;
} & AnnotationTerm<PropertyAnnotationValue<QualifiedTypeName[]>>;
/**

@@ -412,11 +476,17 @@ The qualified name of a term in scope.

*/
export declare type Ordered = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type Ordered = {
term: CoreAnnotationTerms.Ordered;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
Items can be inserted at a given ordinal index.
*/
export declare type PositionalInsert = AnnotationTerm<PropertyAnnotationValue<Tag>>;
export declare type PositionalInsert = {
term: CoreAnnotationTerms.PositionalInsert;
} & AnnotationTerm<PropertyAnnotationValue<Tag>>;
/**
Communicates available alternate keys
*/
export declare type AlternateKeys = AnnotationTerm<AlternateKeyTypes[]>;
export declare type AlternateKeys = {
term: CoreAnnotationTerms.AlternateKeys;
} & AnnotationTerm<AlternateKeyTypes[]>;
export declare type AlternateKey = ComplexType & {

@@ -427,3 +497,3 @@ $Type: CoreAnnotationTypes.AlternateKey;

*/
Key: AnnotationTerm<PropertyRefTypes[]>;
Key: PropertyRefTypes[];
};

@@ -450,3 +520,5 @@ export declare type PropertyRef = ComplexType & {

*/
export declare type OptionalParameter = AnnotationTerm<OptionalParameterTypeTypes>;
export declare type OptionalParameter = {
term: CoreAnnotationTerms.OptionalParameter;
} & AnnotationTerm<OptionalParameterTypeTypes>;
export declare type OptionalParameterType = ComplexType & {

@@ -462,3 +534,5 @@ $Type: CoreAnnotationTypes.OptionalParameterType;

*/
export declare type OperationAvailable = AnnotationTerm<Edm.Boolean>;
export declare type OperationAvailable = {
term: CoreAnnotationTerms.OperationAvailable;
} & AnnotationTerm<Edm.Boolean>;
/**

@@ -471,3 +545,5 @@ A string representing a Local Date-Time value with no offset.

*/
export declare type SymbolicName = AnnotationTerm<PropertyAnnotationValue<SimpleIdentifier>>;
export declare type SymbolicName = {
term: CoreAnnotationTerms.SymbolicName;
} & AnnotationTerm<PropertyAnnotationValue<SimpleIdentifier>>;
/**

@@ -480,3 +556,5 @@ A [simple identifier](https://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/odata-csdl-xml-v4.01.html#sec_SimpleIdentifier)

*/
export declare type GeometryFeature = AnnotationTerm<GeometryFeatureTypeTypes>;
export declare type GeometryFeature = {
term: CoreAnnotationTerms.GeometryFeature;
} & AnnotationTerm<GeometryFeatureTypeTypes>;
/**

@@ -494,3 +572,3 @@ A [Feature Object](https://datatracker.ietf.org/doc/html/rfc7946#section-3.2) represents a spatially bounded thing

*/
properties?: AnnotationTerm<DictionaryTypes>;
properties?: DictionaryTypes;
/**

@@ -563,19 +641,19 @@ Commonly used identifer for a Feature

}
export declare type RevisionTypeTypes = AnnotationTerm<RevisionType>;
export declare type LinkTypes = AnnotationTerm<Link>;
export declare type ExampleValueTypes = AnnotationTerm<ExampleValue | PrimitiveExampleValueTypes | ComplexExampleValueTypes | EntityExampleValueTypes | ExternalExampleValueTypes>;
export declare type PrimitiveExampleValueTypes = AnnotationTerm<PrimitiveExampleValue>;
export declare type ComplexExampleValueTypes = AnnotationTerm<ComplexExampleValue>;
export declare type EntityExampleValueTypes = AnnotationTerm<EntityExampleValue>;
export declare type ExternalExampleValueTypes = AnnotationTerm<ExternalExampleValue>;
export declare type MessageTypeTypes = AnnotationTerm<MessageType>;
export declare type ExceptionTypeTypes = AnnotationTerm<ValueExceptionTypeTypes | ResourceExceptionTypeTypes | DataModificationExceptionTypeTypes>;
export declare type ValueExceptionTypeTypes = AnnotationTerm<ValueExceptionType>;
export declare type ResourceExceptionTypeTypes = AnnotationTerm<ResourceExceptionType>;
export declare type DataModificationExceptionTypeTypes = AnnotationTerm<DataModificationExceptionType>;
export declare type ContentDispositionTypeTypes = AnnotationTerm<ContentDispositionType>;
export declare type AlternateKeyTypes = AnnotationTerm<AlternateKey>;
export declare type PropertyRefTypes = AnnotationTerm<PropertyRef>;
export declare type DictionaryTypes = AnnotationTerm<Dictionary>;
export declare type OptionalParameterTypeTypes = AnnotationTerm<OptionalParameterType>;
export declare type GeometryFeatureTypeTypes = AnnotationTerm<GeometryFeatureType>;
export declare type RevisionTypeTypes = RevisionType;
export declare type LinkTypes = Link;
export declare type ExampleValueTypes = ExampleValue | PrimitiveExampleValueTypes | ComplexExampleValueTypes | EntityExampleValueTypes | ExternalExampleValueTypes;
export declare type PrimitiveExampleValueTypes = PrimitiveExampleValue;
export declare type ComplexExampleValueTypes = ComplexExampleValue;
export declare type EntityExampleValueTypes = EntityExampleValue;
export declare type ExternalExampleValueTypes = ExternalExampleValue;
export declare type MessageTypeTypes = MessageType;
export declare type ExceptionTypeTypes = ValueExceptionTypeTypes | ResourceExceptionTypeTypes | DataModificationExceptionTypeTypes;
export declare type ValueExceptionTypeTypes = ValueExceptionType;
export declare type ResourceExceptionTypeTypes = ResourceExceptionType;
export declare type DataModificationExceptionTypeTypes = DataModificationExceptionType;
export declare type ContentDispositionTypeTypes = ContentDispositionType;
export declare type AlternateKeyTypes = AlternateKey;
export declare type PropertyRefTypes = PropertyRef;
export declare type DictionaryTypes = Dictionary;
export declare type OptionalParameterTypeTypes = OptionalParameterType;
export declare type GeometryFeatureTypeTypes = GeometryFeatureType;

6

vocabularies/Hierarchy.d.ts

@@ -7,3 +7,5 @@ import * as Edm from "../Edm";

*/
export declare type RecursiveHierarchy = AnnotationTerm<RecursiveHierarchyTypeTypes>;
export declare type RecursiveHierarchy = {
term: HierarchyAnnotationTerms.RecursiveHierarchy;
} & AnnotationTerm<RecursiveHierarchyTypeTypes>;
export declare type RecursiveHierarchyType = ComplexType & {

@@ -38,2 +40,2 @@ $Type: HierarchyAnnotationTypes.RecursiveHierarchyType;

}
export declare type RecursiveHierarchyTypeTypes = AnnotationTerm<RecursiveHierarchyType>;
export declare type RecursiveHierarchyTypeTypes = RecursiveHierarchyType;

6

vocabularies/HTML5.d.ts

@@ -8,3 +8,5 @@ import * as Edm from "../Edm";

*/
export declare type CssDefaults = AnnotationTerm<CssDefaultsTypeTypes>;
export declare type CssDefaults = {
term: HTML5AnnotationTerms.CssDefaults;
} & AnnotationTerm<CssDefaultsTypeTypes>;
export declare type CssDefaultsType = ComplexType & {

@@ -23,2 +25,2 @@ $Type: HTML5AnnotationTypes.CssDefaultsType;

}
export declare type CssDefaultsTypeTypes = AnnotationTerm<CssDefaultsType>;
export declare type CssDefaultsTypeTypes = CssDefaultsType;

20

vocabularies/Measures.d.ts

@@ -7,19 +7,29 @@ import * as Edm from "../Edm";

*/
export declare type ISOCurrency = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type ISOCurrency = {
term: MeasuresAnnotationTerms.ISOCurrency;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The number of significant decimal places in the scale part (less than or equal to the number declared in the Scale facet)
*/
export declare type Scale = AnnotationTerm<Edm.Byte>;
export declare type Scale = {
term: MeasuresAnnotationTerms.Scale;
} & AnnotationTerm<Edm.Byte>;
/**
The unit of measure for this measured quantity, e.g. cm for centimeters or % for percentages
*/
export declare type Unit = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Unit = {
term: MeasuresAnnotationTerms.Unit;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The unit of measure for this measured quantity, according to the [UN/CEFACT Recommendation 20](http://tfig.unece.org/contents/recommendation-20.htm)
*/
export declare type UNECEUnit = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type UNECEUnit = {
term: MeasuresAnnotationTerms.UNECEUnit;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
The minimum granularity of duration values.
*/
export declare type DurationGranularity = AnnotationTerm<PropertyAnnotationValue<DurationGranularityType>>;
export declare type DurationGranularity = {
term: MeasuresAnnotationTerms.DurationGranularity;
} & AnnotationTerm<PropertyAnnotationValue<DurationGranularityType>>;
export declare type DurationGranularityType = Edm.String;

@@ -26,0 +36,0 @@ export declare const enum MeasuresAnnotationTerms {

24

vocabularies/PersonalData.d.ts

@@ -8,11 +8,17 @@ import * as Core from "./Core";

*/
export declare type EntitySemantics = AnnotationTerm<PropertyAnnotationValue<EntitySemanticsType>>;
export declare type EntitySemantics = {
term: PersonalDataAnnotationTerms.EntitySemantics;
} & AnnotationTerm<PropertyAnnotationValue<EntitySemanticsType>>;
/**
Role of the data subjects in this set (e.g. employee, customer)
*/
export declare type DataSubjectRole = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type DataSubjectRole = {
term: PersonalDataAnnotationTerms.DataSubjectRole;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Language-dependent description of the role of the data subjects in this set (e.g. employee, customer)
*/
export declare type DataSubjectRoleDescription = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type DataSubjectRoleDescription = {
term: PersonalDataAnnotationTerms.DataSubjectRoleDescription;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**

@@ -25,3 +31,5 @@ Primary meaning of the data contained in the annotated entity set

*/
export declare type FieldSemantics = AnnotationTerm<PropertyAnnotationValue<FieldSemanticsType>>;
export declare type FieldSemantics = {
term: PersonalDataAnnotationTerms.FieldSemantics;
} & AnnotationTerm<PropertyAnnotationValue<FieldSemanticsType>>;
/**

@@ -34,7 +42,11 @@ Primary meaning of a data field

*/
export declare type IsPotentiallyPersonal = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsPotentiallyPersonal = {
term: PersonalDataAnnotationTerms.IsPotentiallyPersonal;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
Property contains potentially sensitive personal data
*/
export declare type IsPotentiallySensitive = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type IsPotentiallySensitive = {
term: PersonalDataAnnotationTerms.IsPotentiallySensitive;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare const enum PersonalDataAnnotationTerms {

@@ -41,0 +53,0 @@ EntitySemantics = "com.sap.vocabularies.PersonalData.v1.EntitySemantics",

6

vocabularies/Session.d.ts

@@ -8,3 +8,5 @@ import * as Common from "./Common";

*/
export declare type StickySessionSupported = AnnotationTerm<StickySessionSupportedTypeTypes>;
export declare type StickySessionSupported = {
term: SessionAnnotationTerms.StickySessionSupported;
} & AnnotationTerm<StickySessionSupportedTypeTypes>;
/**

@@ -42,2 +44,2 @@ Actions for managing data modification within a sticky session

}
export declare type StickySessionSupportedTypeTypes = AnnotationTerm<StickySessionSupportedType>;
export declare type StickySessionSupportedTypeTypes = StickySessionSupportedType;

66

vocabularies/Validation.d.ts

@@ -9,19 +9,29 @@ import * as Core from "./Core";

*/
export declare type Pattern = AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
export declare type Pattern = {
term: ValidationAnnotationTerms.Pattern;
} & AnnotationTerm<PropertyAnnotationValue<Edm.String>>;
/**
Minimum value that a property, parameter, or term can have.
*/
export declare type Minimum = AnnotationTerm<Edm.PrimitiveType>;
export declare type Minimum = {
term: ValidationAnnotationTerms.Minimum;
} & AnnotationTerm<Edm.PrimitiveType>;
/**
Maximum value that a property, parameter, or term can have.
*/
export declare type Maximum = AnnotationTerm<Edm.PrimitiveType>;
export declare type Maximum = {
term: ValidationAnnotationTerms.Maximum;
} & AnnotationTerm<Edm.PrimitiveType>;
/**
Tags a Minimum or Maximum as exclusive, i.e. an open interval boundary.
*/
export declare type Exclusive = AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
export declare type Exclusive = {
term: ValidationAnnotationTerms.Exclusive;
} & AnnotationTerm<PropertyAnnotationValue<Core.Tag>>;
/**
A collection of valid values for the annotated property, parameter, or type definition
*/
export declare type AllowedValues = AnnotationTerm<AllowedValueTypes[]>;
export declare type AllowedValues = {
term: ValidationAnnotationTerms.AllowedValues;
} & AnnotationTerm<AllowedValueTypes[]>;
export declare type AllowedValue = ComplexType & {

@@ -37,7 +47,11 @@ $Type: ValidationAnnotationTypes.AllowedValue;

*/
export declare type MultipleOf = AnnotationTerm<Edm.Decimal>;
export declare type MultipleOf = {
term: ValidationAnnotationTerms.MultipleOf;
} & AnnotationTerm<Edm.Decimal>;
/**
Condition that the annotation target has to fulfill
*/
export declare type Constraint = AnnotationTerm<ConstraintTypeTypes>;
export declare type Constraint = {
term: ValidationAnnotationTerms.Constraint;
} & AnnotationTerm<ConstraintTypeTypes>;
export declare type ConstraintType = ComplexType & {

@@ -57,3 +71,5 @@ $Type: ValidationAnnotationTypes.ConstraintType;

*/
export declare type ItemsOf = AnnotationTerm<ItemsOfTypeTypes[]>;
export declare type ItemsOf = {
term: ValidationAnnotationTerms.ItemsOf;
} & AnnotationTerm<ItemsOfTypeTypes[]>;
/**

@@ -67,7 +83,7 @@ Entities related via the single- or collection-valued navigation property identified by `path` are also related via the collection-valued navigation property identified by `target`.

*/
path: PropertyAnnotationValue<Edm.NavigationPropertyPath>;
path: Edm.NavigationPropertyPath;
/**
A path to a collection-valued navigation property
*/
target: PropertyAnnotationValue<Edm.NavigationPropertyPath>;
target: Edm.NavigationPropertyPath;
};

@@ -77,7 +93,11 @@ /**

*/
export declare type OpenPropertyTypeConstraint = AnnotationTerm<PropertyAnnotationValue<SingleOrCollectionType[]>>;
export declare type OpenPropertyTypeConstraint = {
term: ValidationAnnotationTerms.OpenPropertyTypeConstraint;
} & AnnotationTerm<PropertyAnnotationValue<SingleOrCollectionType[]>>;
/**
Values are restricted to types that are both identical to or derived from the declared type and a type listed in this collection.
*/
export declare type DerivedTypeConstraint = AnnotationTerm<PropertyAnnotationValue<SingleOrCollectionType[]>>;
export declare type DerivedTypeConstraint = {
term: ValidationAnnotationTerms.DerivedTypeConstraint;
} & AnnotationTerm<PropertyAnnotationValue<SingleOrCollectionType[]>>;
/**

@@ -90,15 +110,23 @@ The qualified name of a type in scope, optionally wrapped in `Collection()` to denote a collection of instances of the type

*/
export declare type AllowedTerms = AnnotationTerm<Core.QualifiedTermName[]>;
export declare type AllowedTerms = {
term: ValidationAnnotationTerms.AllowedTerms;
} & AnnotationTerm<Core.QualifiedTermName[]>;
/**
Names of specific terms that are applicable and may be applied in the current context. This annotation does not restrict the use of other terms.
*/
export declare type ApplicableTerms = AnnotationTerm<Core.QualifiedTermName[]>;
export declare type ApplicableTerms = {
term: ValidationAnnotationTerms.ApplicableTerms;
} & AnnotationTerm<Core.QualifiedTermName[]>;
/**
The annotated collection must have at most the specified number of items.
*/
export declare type MaxItems = AnnotationTerm<Edm.Int64>;
export declare type MaxItems = {
term: ValidationAnnotationTerms.MaxItems;
} & AnnotationTerm<Edm.Int64>;
/**
The annotated collection must have at least the specified number of items.
*/
export declare type MinItems = AnnotationTerm<Edm.Int64>;
export declare type MinItems = {
term: ValidationAnnotationTerms.MinItems;
} & AnnotationTerm<Edm.Int64>;
export declare const enum ValidationAnnotationTerms {

@@ -125,4 +153,4 @@ Pattern = "Org.OData.Validation.V1.Pattern",

}
export declare type AllowedValueTypes = AnnotationTerm<AllowedValue>;
export declare type ConstraintTypeTypes = AnnotationTerm<ConstraintType>;
export declare type ItemsOfTypeTypes = AnnotationTerm<ItemsOfType>;
export declare type AllowedValueTypes = AllowedValue;
export declare type ConstraintTypeTypes = ConstraintType;
export declare type ItemsOfTypeTypes = ItemsOfType;
vocabularies/UI.d.ts

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc