@open-resource-discovery/specification 1.13.0 → 1.14.1

package/dist/generated/spec/v1/types/Document.d.ts

@@ -19,7 +19,7 @@ export interface OrdDocument {
     /**
      * Version of the Open Resource Discovery specification that is used to describe this document.
      */
-    openResourceDiscovery: "1.0" | "1.1" | "1.2" | "1.3" | "1.4" | "1.5" | "1.6" | "1.7" | "1.8" | "1.9" | "1.10" | "1.11" | "1.12" | "1.13";
+    openResourceDiscovery: "1.0" | "1.1" | "1.2" | "1.3" | "1.4" | "1.5" | "1.6" | "1.7" | "1.8" | "1.9" | "1.10" | "1.11" | "1.12" | "1.13" | "1.14";
     /**
      * Optional description of the ORD document itself.
      * Please note that this information is NOT further processed or considered by an ORD aggregator.
@@ -87,6 +87,10 @@ export interface OrdDocument {
      * Array of all data products that are described in this ORD document.
      */
     dataProducts?: DataProduct[];
+    /**
+     * Array of all AI Agents that are described in this ORD document.
+     */
+    agents?: Agent[];
     /**
      * Array of all integration dependencies that are described in this ORD document.
      */
@@ -426,11 +430,31 @@ export interface ApiResource {
      */
     lastUpdate?: string;
     /**
-     * The visibility states who is allowed to "see" the described resource or capability.
+     * Indicates that the resource serves as interface only and cannot be called directly, similar to the abstract keyword in programming languages like Java.
+     *
+     * Abstract resources define contracts that other resources can declare compatibility with through the `compatibleWith` property.
+     *
+     * More details can be found on the [Compatibility](../concepts/compatibility) concept page.
+     */
+    abstract?: boolean;
+    /**
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
      */
     visibility: "public" | "internal" | "private";
     /**
-     * The `releaseStatus` specifies the stability of the resource and its external contract.
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
      */
     releaseStatus: "beta" | "active" | "deprecated" | "sunset";
     /**
@@ -554,14 +578,18 @@ export interface ApiResource {
      */
     customImplementationStandardDescription?: string;
     /**
-     * A reference to the interface (API contract) that this API implements.
-     * Serves as a declaration of compatible implementation of API contract, effectively functioning as an "implementationOf" relationship.
+     * A reference to the interface (API contract) and its maximum version that this API implements. Even if the interface contract evolves compatible, this resource will not be compatible with versions beyond the specified one.
+     *
+     * Serves as a declaration of compatible implementation of API contract, effectively functioning as an "implementationOf" relationship. The data that compatible APIs return follow the same schema, but itself can be different.
+     * This means that if one API is returning 1 record for a dedicated request, a compatible API could return multiple and different records, as long as they adhere to the same schema.
      *
      * MUST be a valid reference to an (usually external) [API Resource](#api-resource) ORD ID.
      *
      * All APIs that share the same `compatibleWith` value MAY be treated the same or similar by a consumer client.
+     *
+     * More details can be found on the [Compatibility](../concepts/compatibility) concept page.
      */
-    compatibleWith?: string[];
+    compatibleWith?: APICompatibility[];
     /**
      * Contains typically the organization that is responsible in the sense of RACI matrix for this ORD resource. This includes support and feature requests. It is maintained as correlation id to for example support components.
      */
@@ -704,7 +732,14 @@ export interface ChangelogEntry {
      */
     version: string;
     /**
-     * The `releaseStatus` specifies the stability of the resource and its external contract.
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
      */
     releaseStatus: "beta" | "active" | "deprecated" | "sunset";
     /**
@@ -754,7 +789,7 @@ export interface ApiResourceDefinition {
      * `text/plain` MAY be used for arbitrary plain-text and `application/octet-stream` for arbitrary binary data.
      *
      */
-    mediaType: "application/json" | "application/xml" | "text/yaml" | "text/plain" | "application/octet-stream";
+    mediaType: string;
     /**
      * [URL reference](https://tools.ietf.org/html/rfc3986#section-4.1) (URL or relative reference) to the resource definition file.
      *
@@ -809,6 +844,28 @@ export interface MetadataDefinitionAccessStrategy {
      */
     customDescription?: string;
 }
+/**
+ * Describes the compatibility of the API with other APIs. This can be used to express that an API is compatible with another API version.
+ */
+export interface APICompatibility {
+    /**
+     * ORD ID of the APIResource that serves as contract that this resource is compatible with.
+     *
+     * MUST be a valid reference to an (usually external) [API Resource](#api-resource) ORD ID.
+     */
+    ordId: string;
+    /**
+     * Specifies the maximum version of the interface contract that this resource is compatible with. This is the version, that the resource fully implements and supports.
+     *
+     * Even if the interface contract evolves compatible, this resource will not be compatible with versions beyond the specified one. It is important to consider, given the example of an API version 1.0, that has the fields A and B.
+     * Being compatible with version 1.0 means to have exactly the fields A and B and potential tenant specific extensions in a dedicated namespace.
+     * If an API contract changes to version 1.1 compatible by adding field C, the API declaring compatibility towards 1.0, will miss field C. Only if adopting the contract of 1.1 with having fields A, B, and C, such an API is also
+     * compatible with version 1.1 of the contract. However, a client relying on version 1.0 of the contract, can still work with the API being compatible with version 1.1 of the contract.
+     *
+     * Following the [Semantic Versioning 2.0.0](https://semver.org/) standard, patch versions (x.y.Z) must not have impact on the schema/contract. Therefore, the maxVersion are only the major.minor parts of a semantic version.
+     */
+    maxVersion: string;
+}
 /**
  * An API or Event resource may optionally define its `entityTypeMappings`.
  * This is used to map and correlate the API models to the underlying, conceptual **entity types**.
@@ -860,8 +917,8 @@ export interface EntityTypeMapping {
      * @minItems 1
      */
     entityTypeTargets: [
-        EntityTypeTargetOrdId | EntityTypeTargetCorrelationId,
-        ...(EntityTypeTargetOrdId | EntityTypeTargetCorrelationId)[]
+        EntityTypeTargetORDID | EntityTypeTargetCorrelationId,
+        ...(EntityTypeTargetORDID | EntityTypeTargetCorrelationId)[]
     ];
 }
 /**
@@ -909,7 +966,7 @@ export interface ApiModelSelectorJsonPointer {
  *
  * Entity types can be referenced using a [ORD ID](../index.md#ord-id) of an entity type.
  */
-export interface EntityTypeTargetOrdId {
+export interface EntityTypeTargetORDID {
     /**
      * The ORD ID is a stable, globally unique ID for ORD resources or taxonomy.
      *
@@ -1149,11 +1206,31 @@ export interface EventResource {
      */
     lastUpdate?: string;
     /**
-     * The visibility states who is allowed to "see" the described resource or capability.
+     * Indicates that the resource serves as interface only and cannot be called directly, similar to the abstract keyword in programming languages like Java.
+     *
+     * Abstract resources define contracts that other resources can declare compatibility with through the `compatibleWith` property.
+     *
+     * More details can be found on the [Compatibility](../concepts/compatibility) concept page.
+     */
+    abstract?: boolean;
+    /**
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
      */
     visibility: "public" | "internal" | "private";
     /**
-     * The `releaseStatus` specifies the stability of the resource and its external contract.
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
      */
     releaseStatus: "beta" | "active" | "deprecated" | "sunset";
     /**
@@ -1245,14 +1322,16 @@ export interface EventResource {
      */
     customImplementationStandardDescription?: string;
     /**
-     * Declares this event resource is a compatible implementation of the referenced contract.
-     * This is also sometimes known as [Service Provider Interface](https://en.wikipedia.org/wiki/Service_provider_interface).
+     * A reference to the interface (event contract) and its maximum version that this event implements. Even if the interface contract evolves compatible, this resource will not be compatible with versions beyond the specified one.
      *
-     * MUST be a valid reference to an (usually external) [Event Resource](#event-resource) ORD ID.
+     * Serves as a declaration of compatible implementation of event contract, effectively functioning as an "implementationOf" relationship. The data that compatible events return follow the same schema, but itself can be different.
+     * This means that if one event is returning 1 record for a dedicated request, a compatible event could return multiple and different records, as long as they adhere to the same schema.
      *
-     * All event resources that share the same `compatibleWith` value MAY be treated the same or similar by a consumer client.
+     * All events that share the same `compatibleWith` value MAY be treated the same or similar by a consumer client.
+     *
+     * More details can be found on the [Compatibility](../concepts/compatibility) concept page.
      */
-    compatibleWith?: string[];
+    compatibleWith?: EventCompatibility[];
     /**
      * Contains typically the organization that is responsible in the sense of RACI matrix for this ORD resource. This includes support and feature requests. It is maintained as correlation id to for example support components.
      */
@@ -1376,7 +1455,7 @@ export interface EventResourceDefinition {
      * `text/plain` MAY be used for arbitrary plain-text and `application/octet-stream` for arbitrary binary data.
      *
      */
-    mediaType: "application/json" | "application/xml" | "text/yaml" | "text/plain" | "application/octet-stream";
+    mediaType: string;
     /**
      * [URL reference](https://tools.ietf.org/html/rfc3986#section-4.1) (URL or relative reference) to the resource definition file.
      *
@@ -1408,6 +1487,27 @@ export interface EventResourceDefinition {
      */
     visibility?: "public" | "internal" | "private";
 }
+/**
+ * Describes the compatibility of the Event with other Events. This can be used to express that an Event is compatible with another Event version.
+ */
+export interface EventCompatibility {
+    /**
+     * ORD ID of the EventResource that serves as contract that this resource is compatible with.
+     *
+     * MUST be a valid reference to an (usually external) [Event Resource](#event-resource) ORD ID.
+     */
+    ordId: string;
+    /**
+     * Specifies the maximum version of the interface contract that this resource is compatible with. This is the version, that the resource fully implements and supports.
+     *
+     * Even if the interface contract evolves compatible, this resource will not be compatible with versions beyond the specified one. It is important to consider, given the example of an event version 1.0, that has the fields A and B. Being compatible with version 1.0 means to have exactly the fields A and B and potential tenant specific extensions in a dedicated namespace.
+     * If an event contract changes to version 1.1 compatible by adding field C, the event declaring compatibility towards 1.0, will miss field C. Only if adopting the contract of 1.1 with having fields A, B, and C, such an event is also
+     * compatible with version 1.1 of the contract. However, a client relying on version 1.0 of the contract, can still work with the event being compatible with version 1.1 of the contract.
+     *
+     * Following the [Semantic Versioning 2.0.0](https://semver.org/) standard, patch versions (x.y.Z) must not have impact on the schema/contract. Therefore, the maxVersion are only the major.minor parts of a semantic version.
+     */
+    maxVersion: string;
+}
 /**
  * An [**Entity Type**](../concepts/grouping-and-bundling#entity-type) describes either a business concept / term or an underlying conceptual model.
  * The same entity type can be exposed through one or multiple API and events resources.
@@ -1523,11 +1623,23 @@ export interface EntityType {
      */
     lastUpdate?: string;
     /**
-     * The visibility states who is allowed to "see" the described resource or capability.
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
      */
     visibility: "public" | "internal" | "private";
     /**
-     * The `releaseStatus` specifies the stability of the resource and its external contract.
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
      */
     releaseStatus: "beta" | "active" | "deprecated" | "sunset";
     /**
@@ -1766,11 +1878,23 @@ export interface Capability {
      */
     lastUpdate?: string;
     /**
-     * The visibility states who is allowed to "see" the described resource or capability.
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
      */
     visibility: "public" | "internal" | "private";
     /**
-     * The `releaseStatus` specifies the stability of the resource and its external contract.
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
      */
     releaseStatus: "beta" | "active" | "deprecated" | "sunset";
     /**
@@ -1863,7 +1987,7 @@ export interface CapabilityDefinition {
      * `text/plain` MAY be used for arbitrary plain-text and `application/octet-stream` for arbitrary binary data.
      *
      */
-    mediaType: "application/json" | "application/xml" | "text/yaml" | "text/plain" | "application/octet-stream";
+    mediaType: string;
     /**
      * [URL reference](https://tools.ietf.org/html/rfc3986#section-4.1) (URL or relative reference) to the resource definition file.
      *
@@ -2031,6 +2155,12 @@ export interface DataProduct {
      *
      */
     disabled?: boolean;
+    /**
+     * Indicates that the data product serves as interface only. All output ports MUST be marked as abstract.
+     *
+     * Implementations of this data product MUST declare compatible with on their specific output port resources as consumption of data products happens through the output ports.
+     */
+    abstract?: boolean;
     /**
      * The resource has been introduced in the given [system version](../index.md#system-version).
      * This implies that the resource is only available if the system instance is of at least that system version.
@@ -2245,6 +2375,272 @@ export interface DataProductLink {
      */
     url: string;
 }
+/**
+ * An **Agent** provides a high-level description of an AI-powered autonomous system that can perform tasks, make decisions, and interact with users or other systems to achieve specific business goals.
+ *
+ * An Agent can relate to specific entity types it works with, declare integration dependencies on external systems it requires, and expose its capabilities through APIs using protocols like A2A (Agent-to-Agent).
+ *
+ * Agents enable intelligent automation and decision-making within business processes by providing semantic understanding and context-aware capabilities beyond traditional API-based integrations.
+ *
+ * For more details, see [AI Agents and Protocols](../concepts/ai-agents-and-protocols.md).
+ */
+export interface Agent {
+    /**
+     * The ORD ID is a stable, globally unique ID for ORD resources or taxonomy.
+     *
+     * It MUST be a valid [ORD ID](../index.md#ord-id) of the appropriate ORD type.
+     */
+    ordId: string;
+    /**
+     * The locally unique ID under which this resource can be looked up / resolved in the described system itself.
+     * Unlike the ORD ID it's not globally unique, but it may be useful to document the original ID / technical name.
+     *
+     * It MAY also be used as the `<resourceName>` fragment in the ORD ID, IF it can fulfill the charset and length limitations within the ORD ID.
+     * But since this is not always possible, no assumptions MUST be made about the local ID being the same as the `<resourceName>` fragment in the ORD ID.
+     */
+    localId?: string;
+    /**
+     * Correlation IDs can be used to create a reference to related data in other repositories (especially to the system of record).
+     *
+     * They express an "identity" / "equals" / "mappable" relationship to the target ID.
+     *
+     * If a "part of" relationship needs to be expressed, use the `partOfGroups` assignment instead.
+     *
+     * MUST be a valid [Correlation ID](../index.md#correlation-id).
+     */
+    correlationIds?: string[];
+    /**
+     * Human-readable title.
+     *
+     * MUST NOT exceed 255 chars.
+     * MUST NOT contain line breaks.
+     */
+    title: string;
+    /**
+     * Plain text short description.
+     *
+     * MUST NOT exceed 255 chars.
+     * MUST NOT contain line breaks.
+     */
+    shortDescription?: string;
+    /**
+     * Full description, notated in [CommonMark](https://spec.commonmark.org/) (Markdown).
+     *
+     * The description SHOULD not be excessive in length and is not meant to provide full documentation.
+     * Detailed documentation SHOULD be attached as (typed) links.
+     */
+    description?: string;
+    /**
+     * Defines which Package the resource is part of.
+     *
+     * MUST be a valid reference to a [Package](#package) ORD ID.
+     *
+     * Every resource MUST be part of one package.
+     */
+    partOfPackage: string;
+    /**
+     * Defines which groups the resource is assigned to.
+     *
+     * The property is optional, but if given the value MUST be an array of valid Group IDs.
+     *
+     * Groups are a lightweight custom taxonomy concept.
+     * They express a "part of" relationship to the chosen group concept.
+     * If an "identity / equals" relationship needs to be expressed, use the `correlationIds` instead.
+     *
+     * All resources that share the same group ID assignment are effectively grouped together.
+     */
+    partOfGroups?: string[];
+    /**
+     * The complete [SemVer](https://semver.org/) version string.
+     *
+     * It MUST follow the [Semantic Versioning 2.0.0](https://semver.org/) standard.
+     * It SHOULD be changed if the ORD information or referenced resource definitions changed.
+     * It SHOULD express minor and patch changes that don't lead to incompatible changes.
+     *
+     * When the `version` major version changes, the [ORD ID](../index.md#ord-id) `<majorVersion>` fragment MUST be updated to be identical.
+     * In case that a resource definition file also contains a version number (e.g. [OpenAPI `info`.`version`](https://spec.openapis.org/oas/v3.1.1.html#info-object)), it MUST be equal with the resource `version` to avoid inconsistencies.
+     *
+     * If the resource has been extended by the user, the change MUST be indicated via `lastUpdate`.
+     * The `version` MUST not be bumped for changes in extensions.
+     *
+     * The general [Version and Lifecycle](../index.md#version-and-lifecycle) flow MUST be followed.
+     *
+     * Note: A change is only relevant for a version increment, if it affects the ORD resource or ORD taxonomy directly.
+     * For example: If a resource within a `Package` changes, but the Package itself did not, the Package version does not need to be incremented.
+     */
+    version: string;
+    /**
+     * Optional, but RECOMMENDED indicator when (date-time) the last change to the resource (including its definitions) happened.
+     *
+     * The date format MUST comply with [RFC 3339, section 5.6](https://tools.ietf.org/html/rfc3339#section-5.6).
+     *
+     * When retrieved from an ORD aggregator, `lastUpdate` will be reliable there and reflect either the provider based update time or the aggregator processing time.
+     * Therefore consumers MAY rely on it to detect changes to the metadata and the attached resource definition files.
+     *
+     * If the resource has attached definitions, either the `version` or `lastUpdate` property MUST be defined and updated to let the ORD aggregator know that they need to be fetched again.
+     *
+     * Together with `perspectives`, this property SHOULD be used to optimize the metadata crawling process of the ORD aggregators.
+     */
+    lastUpdate?: string;
+    /**
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
+     */
+    visibility: "public" | "internal" | "private";
+    /**
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
+     */
+    releaseStatus: "beta" | "active" | "deprecated" | "sunset";
+    /**
+     * Indicates that this resource is currently not available for consumption at runtime, but could be configured to be so.
+     * This can happen either because it has not been setup for use or disabled by an admin / user.
+     *
+     * If the resource is not available in principle for a particular system instance, e.g. due to lack of entitlement, it MUST not be described in the system-instance-aware perspective.
+     *
+     * This property can only reflect the knowledge of the described system instance itself.
+     * Outside factors for availability can't need to be considered (e.g. network connectivity, middlewares).
+     *
+     * A disabled resource MAY skip describing its resource definitions.
+     *
+     */
+    disabled?: boolean;
+    /**
+     * The resource has been introduced in the given [system version](../index.md#system-version).
+     * This implies that the resource is only available if the system instance is of at least that system version.
+     *
+     * It MUST follow the [Semantic Versioning 2.0.0](https://semver.org/) standard.
+     */
+    minSystemVersion?: string;
+    /**
+     * List of products the resources of the Package are a part of.
+     *
+     * MUST be a valid reference to a [Product](#product) ORD ID.
+     *
+     * `partOfProducts` that are assigned to a `Package` are inherited to all of the ORD resources it contains.
+     *
+     * @minItems 0
+     */
+    partOfProducts?: string[];
+    /**
+     * Contains typically the organization that is responsible in the sense of RACI matrix for this ORD resource. This includes support and feature requests. It is maintained as correlation id to for example support components.
+     */
+    responsible?: string;
+    /**
+     * The deprecation date defines when the resource has been set as deprecated.
+     * This is not to be confused with the `sunsetDate` which defines when the resource will be actually sunset, aka. decommissioned / removed / archived.
+     *
+     * The date format MUST comply with [RFC 3339, section 5.6](https://tools.ietf.org/html/rfc3339#section-5.6).
+     */
+    deprecationDate?: string;
+    /**
+     * The sunset date defines when the resource is scheduled to be decommissioned / removed / archived.
+     *
+     * If the `releaseStatus` is set to `deprecated`, the `sunsetDate` SHOULD be provided (if already known).
+     * Once the sunset date is known and ready to be communicated externally, it MUST be provided here.
+     *
+     * The date format MUST comply with [RFC 3339, section 5.6](https://tools.ietf.org/html/rfc3339#section-5.6).
+     */
+    sunsetDate?: string;
+    /**
+     * The successor resource(s).
+     *
+     * MUST be a valid reference to an ORD ID.
+     *
+     * If the `releaseStatus` is set to `deprecated`, `successors` MUST be provided if one exists.
+     * If `successors` is given, the described resource SHOULD set its `releaseStatus` to `deprecated`.
+     */
+    successors?: string[];
+    /**
+     * Contains changelog entries that summarize changes with special regards to version and releaseStatus
+     */
+    changelogEntries?: ChangelogEntry[];
+    /**
+     * A list of [policy levels](../../spec-extensions/policy-levels/) that the described resources need to be compliant with.
+     * For each chosen policy level, additional expectations and validations rules will be applied.
+     *
+     * Policy levels can be defined on ORD Document level, but also be overwritten on an individual package or resource level.
+     *
+     * A policy level MUST be a valid [Specification ID](../index.md#specification-id).
+     */
+    policyLevels?: string[];
+    /**
+     * List of countries that the Package resources are applicable to.
+     *
+     * MUST be expressed as an array of country codes according to [IES ISO-3166 ALPHA-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
+     *
+     * `countries` that are assigned to a `Package` are inherited to all of the ORD resources it contains.
+     */
+    countries?: string[];
+    /**
+     * List of line of business tags.
+     * No special characters are allowed except `-`, `_`, `.`, `/` and ` `.
+     *
+     * `lineOfBusiness` that are assigned to a `Package` are inherited to all of the ORD resources it contains.
+     */
+    lineOfBusiness?: ((string | "Asset Management" | "Commerce" | "Finance" | "Human Resources" | "Manufacturing" | "Marketing" | "R&D Engineering" | "Sales" | "Service" | "Sourcing and Procurement" | "Strategy, Compliance, and Governance" | "Supply Chain" | "Sustainability" | "Metering" | "Grid Operations and Maintenance" | "Plant Operations and Maintenance" | "Maintenance and Engineering") & string)[];
+    /**
+     * List of industry tags.
+     * No special characters are allowed except `-`, `_`, `.`, `/` and ` `.
+     *
+     * `industry` that are assigned to a `Package` are inherited to all of the ORD resources it contains.
+     */
+    industry?: ((string | "Aerospace and Defense" | "Agribusiness" | "Automotive" | "Banking" | "Chemicals" | "Consumer Industries" | "Consumer Products" | "Defense and Security" | "Discrete Industries" | "Energy and Natural Resources" | "Engineering Construction and Operations" | "Financial Services" | "Future Cities" | "Healthcare" | "High Tech" | "Higher Education and Research" | "Industrial Machinery and Components" | "Insurance" | "Life Sciences" | "Media" | "Mill Products" | "Mining" | "Oil and Gas" | "Professional Services" | "Public Sector" | "Public Services" | "Retail" | "Service Industries" | "Sports and Entertainment" | "Telecommunications" | "Travel and Transportation" | "Utilities" | "Wholesale Distribution") & string)[];
+    /**
+     * Optional list of related EntityType Resources.
+     *
+     * MUST be a valid reference to an [EntityType Resource](#entity-type) ORD ID.
+     */
+    relatedEntityTypes?: string[];
+    /**
+     * Optional list of API Resources that expose the functionality of the agent. Typically using the A2A protocol, but other protocols are possible as well.
+     *
+     * MUST be a valid reference to an [API Resource](#api-resource) ORD ID.
+     */
+    exposedApiResources?: ExposedAPIResource[];
+    /**
+     * Optional list of integration dependencies that the agent relies on.
+     *
+     * MUST be a valid reference to an [Integration Dependency](#integration-dependency) ORD ID.
+     */
+    integrationDependencies?: string[];
+    /**
+     * Generic Links with arbitrary meaning and content.
+     */
+    links?: Link[];
+    /**
+     * List of free text style tags.
+     * No special characters are allowed except `-`, `_`, `.`, `/` and ` `.
+     *
+     * Tags that are assigned to a `Package` are inherited to all of the ORD resources it contains.
+     */
+    tags?: string[];
+    labels?: Labels;
+    documentationLabels?: DocumentationLabels;
+}
+/**
+ * Reference to an API Resource that exposes the functionality of an agent.
+ *
+ * This is a complex object to allow additional properties / selections to be attached in the future.
+ */
+export interface ExposedAPIResource {
+    /**
+     * The API Resource ORD ID that this reference points to.
+     *
+     * MUST be a valid reference to an [API Resource](#api-resource) ORD ID.
+     */
+    ordId: string;
+}
 /**
  * An [Integration Dependency](../concepts/integration-dependency) states that the described system (self) can integrate with external systems (integration target) to achieve an integration purpose.
  * The purpose could be to enable a certain feature or integration scenario, but it could also be a mandatory prerequisite for the described system to work.
@@ -2365,11 +2761,23 @@ export interface IntegrationDependency {
      */
     lastUpdate?: string;
     /**
-     * The visibility states who is allowed to "see" the described resource or capability.
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
      */
     visibility: "public" | "internal" | "private";
     /**
-     * The `releaseStatus` specifies the stability of the resource and its external contract.
+     * Defines the maturity level and stability commitment for the resource's API contract (interface, behavior, data models).
+     *
+     * This indicates whether the resource may undergo backward-incompatible changes. It helps consumers understand the risk
+     * of depending on the resource and whether it's suitable for production use.
+     *
+     * Note: This is independent of `visibility` and does not imply availability guarantees or SLAs - it concerns only the API contract stability.
+     *
+     * See [Lifecycle](../index.md#lifecycle) and [Compatibility](../concepts/compatibility.md) for more details.
      */
     releaseStatus: "beta" | "active" | "deprecated" | "sunset";
     /**
@@ -2476,6 +2884,25 @@ export interface ApiResourceIntegrationAspect {
      *
      */
     minVersion?: string;
+    /**
+     * List of individual API operations that are sufficient to achieve the aspect.
+     */
+    subset?: APIResourceIntegrationAspectSubset[];
+}
+/**
+ * Defines that API Resource Integration Aspect only requires a subset of the referenced contract.
+ *
+ * For APIs, this is a list of the operations or tools that need to be available in order to make the integration work.
+ * This information helps to narrow down what is really necessary and can help optimize the integration.
+ */
+export interface APIResourceIntegrationAspectSubset {
+    /**
+     * The ID of the individual API operation or tool.
+     *
+     * This MUST be an ID that is understood by the used protocol and resource definition format.
+     * E.g. for OpenAPI this is the `operationId`, for MCP this is the tool `name`.
+     */
+    operationId: string;
 }
 /**
  * Event resource related integration aspect
@@ -2933,7 +3360,12 @@ export interface ConsumptionBundle {
      */
     lastUpdate?: string;
     /**
-     * The visibility states who is allowed to "see" the described resource or capability.
+     * Defines metadata access control - which categories of consumers are allowed to discover and access the resource and its metadata.
+     *
+     * This controls who can see that the resource exists and retrieve its metadata level information.
+     * It does NOT control runtime access to the resource itself - that is managed separately through authentication and authorization mechanisms.
+     *
+     * Use this to prevent exposing internal implementation details to inappropriate consumer audiences.
      */
     visibility?: "public" | "internal" | "private";
     /**
@@ -3035,6 +3467,17 @@ export interface Group {
      * Detailed documentation SHOULD be attached as (typed) links.
      */
     description?: string;
+    labels?: Labels;
+    /**
+     * Correlation IDs can be used to create a reference to related data in other repositories (especially to the system of record).
+     *
+     * They express an "identity" / "equals" / "mappable" relationship to the target ID.
+     *
+     * If a "part of" relationship needs to be expressed, use the `partOfGroups` assignment instead.
+     *
+     * MUST be a valid [Correlation ID](../index.md#correlation-id).
+     */
+    correlationIds?: string[];
     /**
      * A group (instance) can logically be part of another group, for example in hierarchical taxonomies or graph relationships.
      * Assigning a group to be part of another group is a lightweight and flexible approach to express such relationships.
@@ -3068,6 +3511,17 @@ export interface GroupType {
      * Detailed documentation SHOULD be attached as (typed) links.
      */
     description?: string;
+    labels?: Labels;
+    /**
+     * Correlation IDs can be used to create a reference to related data in other repositories (especially to the system of record).
+     *
+     * They express an "identity" / "equals" / "mappable" relationship to the target ID.
+     *
+     * If a "part of" relationship needs to be expressed, use the `partOfGroups` assignment instead.
+     *
+     * MUST be a valid [Correlation ID](../index.md#correlation-id).
+     */
+    correlationIds?: string[];
     /**
      * A group type can logically be part of another group type, for example in hierarchical taxonomies or graph relationships.
      * Assigning a group type to be part of another group type is a lightweight and flexible approach to express such relationships.