@twin.org/auditable-item-stream-service 0.0.1-next.8 → 0.0.1

package/dist/esm/index.mjs

@@ -1,12 +1,12 @@
 import { HttpParameterHelper } from '@twin.org/api-models';
-import { AuditableItemStreamTypes } from '@twin.org/auditable-item-stream-models';
-import { Guards, ComponentFactory, StringHelper, Is, Validation, Converter, RandomHelper, Urn, ObjectHelper, GeneralError, NotFoundError, Coerce } from '@twin.org/core';
+import { AuditableItemStreamTypes, AuditableItemStreamContexts, AuditableItemStreamTopics } from '@twin.org/auditable-item-stream-models';
+import { Guards, ComponentFactory, Coerce, StringHelper, Is, Validation, Converter, RandomHelper, ObjectHelper, GeneralError, Urn, NotFoundError } from '@twin.org/core';
+import { SchemaOrgTypes, SchemaOrgContexts, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
 import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
 import { JsonLdHelper, JsonLdProcessor, JsonLdTypes } from '@twin.org/data-json-ld';
-import { SchemaOrgDataTypes, SchemaOrgTypes } from '@twin.org/data-schema-org';
 import { SortDirection, LogicalOperator, ComparisonOperator, property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
-import { ImmutableProofTypes } from '@twin.org/immutable-proof-models';
+import { ImmutableProofContexts } from '@twin.org/immutable-proof-models';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -44,15 +44,15 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                     id: "auditableItemStreamCreateRequestExample",
                     request: {
                         body: {
-                            streamObject: {
-                                "@context": "http://schema.org/",
+                            annotationObject: {
+                                "@context": "https://schema.org",
                                 "@type": "Note",
                                 content: "This is a simple note"
                             },
                             entries: [
                                 {
                                     entryObject: {
-                                        "@context": "http://schema.org/",
+                                        "@context": "https://schema.org",
                                         "@type": "Event",
                                         startDate: "2011-04-09T20:00:00Z",
                                         description: "A description of the event"
@@ -113,13 +113,16 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamGetResponseExample",
                         response: {
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: AuditableItemStreamTypes.Stream,
                                 id: "ais:1234567890",
                                 dateCreated: "2024-08-22T11:55:16.271Z",
                                 dateModified: "2024-08-22T11:55:16.271Z",
-                                streamObject: {
-                                    "@context": "http://schema.org/",
+                                annotationObject: {
+                                    "@context": "https://schema.org",
                                     "@type": "Note",
                                     content: "This is a simple note"
                                 },
@@ -129,14 +132,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 immutableInterval: 10,
                                 entries: [
                                     {
-                                        "@context": AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            AuditableItemStreamContexts.ContextRoot,
+                                            AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: AuditableItemStreamTypes.StreamEntry,
                                         id: "tst:1234567890",
                                         dateCreated: "2024-08-22T11:55:16.271Z",
                                         proofId: "0101010101010101010101010101010101010101010101010101010101010101",
                                         index: 0,
                                         entryObject: {
-                                            "@context": "http://schema.org/",
+                                            "@context": "https://schema.org",
                                             "@type": "Event",
                                             startDate: "2011-04-09T20:00:00Z",
                                             description: "A description of the event"
@@ -159,13 +165,16 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [HeaderTypes.ContentType]: MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: AuditableItemStreamTypes.Stream,
                                 id: "ais:1234567890",
                                 dateCreated: "2024-08-22T11:55:16.271Z",
                                 dateModified: "2024-08-22T11:55:16.271Z",
-                                streamObject: {
-                                    "@context": "http://schema.org/",
+                                annotationObject: {
+                                    "@context": "https://schema.org",
                                     "@type": "Note",
                                     content: "This is a simple note"
                                 },
@@ -175,14 +184,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 immutableInterval: 10,
                                 entries: [
                                     {
-                                        "@context": AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            AuditableItemStreamContexts.ContextRoot,
+                                            AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: AuditableItemStreamTypes.StreamEntry,
                                         id: "tst:1234567890",
                                         dateCreated: "2024-08-22T11:55:16.271Z",
                                         proofId: "0101010101010101010101010101010101010101010101010101010101010101",
                                         index: 0,
                                         entryObject: {
-                                            "@context": "http://schema.org/",
+                                            "@context": "https://schema.org",
                                             "@type": "Event",
                                             startDate: "2011-04-09T20:00:00Z",
                                             description: "A description of the event"
@@ -216,8 +228,8 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                             id: "ais:1234567890"
                         },
                         body: {
-                            streamObject: {
-                                "@context": "http://schema.org/",
+                            annotationObject: {
+                                "@context": "https://schema.org",
                                 "@type": "Note",
                                 content: "This is a simple note"
                             }
@@ -235,6 +247,35 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
             }
         ]
     };
+    const deleteRoute = {
+        operationId: "auditableItemStreamDelete",
+        summary: "Delete a stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:id`,
+        handler: async (httpRequestContext, request) => auditableItemStreamDelete(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamDeleteRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamDeleteRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
     const listRoute = {
         operationId: "auditableItemStreamList",
         summary: "Query streams",
@@ -259,17 +300,24 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamListResponseExample",
                         response: {
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
-                                type: AuditableItemStreamTypes.StreamList,
-                                streams: [
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamList],
+                                [SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            AuditableItemStreamContexts.ContextRoot,
+                                            AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: AuditableItemStreamTypes.Stream,
                                         id: "ais:1234567890",
                                         dateCreated: "2024-08-22T11:55:16.271Z",
                                         dateModified: "2024-08-22T11:55:16.271Z",
-                                        streamObject: {
-                                            "@context": "http://schema.org/",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
                                             "@type": "Note",
                                             content: "This is a simple note"
                                         },
@@ -279,7 +327,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                         immutableInterval: 10
                                     }
                                 ],
-                                cursor: "1"
+                                [SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -296,17 +344,24 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [HeaderTypes.ContentType]: MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
-                                type: AuditableItemStreamTypes.StreamList,
-                                streams: [
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamList],
+                                [SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            AuditableItemStreamContexts.ContextRoot,
+                                            AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: AuditableItemStreamTypes.Stream,
                                         id: "ais:1234567890",
                                         dateCreated: "2024-08-22T11:55:16.271Z",
                                         dateModified: "2024-08-22T11:55:16.271Z",
-                                        streamObject: {
-                                            "@context": "http://schema.org/",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
                                             "@type": "Note",
                                             content: "This is a simple note"
                                         },
@@ -316,7 +371,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                         immutableInterval: 10
                                     }
                                 ],
-                                cursor: "1"
+                                [SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -345,7 +400,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         },
                         body: {
                             entryObject: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Event",
                                 startDate: "2011-04-09T20:00:00Z",
                                 description: "A description of the event"
@@ -381,7 +436,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
         path: `${baseRouteName}/:id/:entryId`,
         handler: async (httpRequestContext, request) => auditableItemStreamDeleteEntry(httpRequestContext, componentName, request),
         requestType: {
-            type: "IAuditableItemStreamGetRequest",
+            type: "IAuditableItemStreamDeleteRequest",
             examples: [
                 {
                     id: "auditableItemStreamDeleteEntryRequestExample",
@@ -422,7 +477,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         },
                         body: {
                             entryObject: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Note",
                                 content: "This is a simple note"
                             }
@@ -469,14 +524,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamGetEntryResponseExample",
                         response: {
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: AuditableItemStreamTypes.StreamEntry,
                                 id: "tst:1234567890",
                                 dateCreated: "2024-08-22T11:55:16.271Z",
                                 proofId: "0101010101010101010101010101010101010101010101010101010101010101",
                                 index: 0,
                                 entryObject: {
-                                    "@context": "http://schema.org/",
+                                    "@context": "https://schema.org",
                                     "@type": "Event",
                                     startDate: "2011-04-09T20:00:00Z",
                                     description: "A description of the event"
@@ -497,14 +555,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [HeaderTypes.ContentType]: MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: AuditableItemStreamTypes.StreamEntry,
                                 id: "tst:1234567890",
                                 dateCreated: "2024-08-22T11:55:16.271Z",
                                 proofId: "0101010101010101010101010101010101010101010101010101010101010101",
                                 index: 0,
                                 entryObject: {
-                                    "@context": "http://schema.org/",
+                                    "@context": "https://schema.org",
                                     "@type": "Event",
                                     startDate: "2011-04-09T20:00:00Z",
                                     description: "A description of the event"
@@ -548,7 +609,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamGetEntryObjectResponseExample",
                         response: {
                             body: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Event",
                                 startDate: "2011-04-09T20:00:00Z",
                                 description: "A description of the event"
@@ -590,25 +651,32 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamListEntriesResponseExample",
                         response: {
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
-                                type: AuditableItemStreamTypes.StreamEntryList,
-                                entries: [
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                                [SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            AuditableItemStreamContexts.ContextRoot,
+                                            AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: AuditableItemStreamTypes.StreamEntry,
                                         id: "tst:1234567890",
                                         dateCreated: "2024-08-22T11:55:16.271Z",
                                         proofId: "0101010101010101010101010101010101010101010101010101010101010101",
                                         index: 0,
                                         entryObject: {
-                                            "@context": "http://schema.org/",
+                                            "@context": "https://schema.org",
                                             "@type": "Event",
                                             startDate: "2011-04-09T20:00:00Z",
                                             description: "A description of the event"
                                         }
                                     }
                                 ],
-                                cursor: "1"
+                                [SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -625,25 +693,32 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [HeaderTypes.ContentType]: MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
-                                type: AuditableItemStreamTypes.StreamEntryList,
-                                entries: [
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                                [SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            AuditableItemStreamContexts.ContextRoot,
+                                            AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: AuditableItemStreamTypes.StreamEntry,
                                         id: "tst:1234567890",
                                         dateCreated: "2024-08-22T11:55:16.271Z",
                                         proofId: "0101010101010101010101010101010101010101010101010101010101010101",
                                         index: 0,
                                         entryObject: {
-                                            "@context": "http://schema.org/",
+                                            "@context": "https://schema.org",
                                             "@type": "Event",
                                             startDate: "2011-04-09T20:00:00Z",
                                             description: "A description of the event"
                                         }
                                     }
                                 ],
-                                cursor: "1"
+                                [SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -682,17 +757,21 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamListEntryObjectsResponseExample",
                         response: {
                             body: {
-                                "@context": AuditableItemStreamTypes.ContextRoot,
-                                type: AuditableItemStreamTypes.StreamEntryObjectList,
-                                entryObjects: [
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRoot,
+                                    AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryObjectList],
+                                [SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": "http://schema.org/",
+                                        "@context": "https://schema.org",
                                         "@type": "Event",
                                         startDate: "2011-04-09T20:00:00Z",
                                         description: "A description of the event"
                                     }
                                 ],
-                                cursor: "1"
+                                [SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -707,6 +786,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
         createRoute,
         getRoute,
         updateRoute,
+        deleteRoute,
         listRoute,
         createEntryRoute,
         getEntryRoute,
@@ -726,8 +806,12 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
  */
 async function auditableItemStreamCreate(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.body", request.body);
     const component = ComponentFactory.get(componentName);
-    const id = await component.create(request.body?.streamObject, request.body?.entries, {
+    const id = await component.create({
+        annotationObject: request.body.annotationObject,
+        entries: request.body.entries
+    }, {
         immutableInterval: request.body?.immutableInterval
     }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
@@ -751,10 +835,10 @@ async function auditableItemStreamGet(httpRequestContext, componentName, request
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const component = ComponentFactory.get(componentName);
     const result = await component.get(request.pathParams.id, {
-        includeEntries: request.query?.includeEntries,
-        includeDeleted: request.query?.includeDeleted,
-        verifyStream: request.query?.verifyStream,
-        verifyEntries: request.query?.verifyEntries
+        includeEntries: Coerce.boolean(request.query?.includeEntries),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
+        verifyStream: Coerce.boolean(request.query?.verifyStream),
+        verifyEntries: Coerce.boolean(request.query?.verifyEntries)
     });
     return {
         headers: {
@@ -771,11 +855,32 @@ async function auditableItemStreamGet(httpRequestContext, componentName, request
  * @returns The response object with additional http response properties.
  */
 async function auditableItemStreamUpdate(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = ComponentFactory.get(componentName);
+    await component.update({
+        id: request.pathParams.id,
+        annotationObject: request.body.annotationObject
+    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
+/**
+ * Delete the stream.
+ * @param httpRequestContext The request context for the API.
+ * @param componentName The name of the component to use in the routes.
+ * @param request The request.
+ * @returns The response object with additional http response properties.
+ */
+async function auditableItemStreamDelete(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
     Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
     Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
     const component = ComponentFactory.get(componentName);
-    await component.update(request.pathParams.id, request.body?.streamObject, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    await component.remove(request.pathParams.id, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         statusCode: HttpStatusCode.noContent
     };
@@ -792,7 +897,7 @@ async function auditableItemStreamList(httpRequestContext, componentName, reques
     Guards.object(ROUTES_SOURCE, "request.query", request.query);
     const component = ComponentFactory.get(componentName);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
-    const result = await component.query(HttpParameterHelper.conditionsFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, HttpParameterHelper.arrayFromString(request.query?.properties), request.query?.cursor, request.query?.pageSize);
+    const result = await component.query(HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, HttpParameterHelper.arrayFromString(request.query?.properties), request.query?.cursor, Coerce.integer(request.query?.pageSize));
     return {
         headers: {
             [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
@@ -875,7 +980,7 @@ async function auditableItemStreamGetEntry(httpRequestContext, componentName, re
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const component = ComponentFactory.get(componentName);
     const result = await component.getEntry(request.pathParams.id, request.pathParams.entryId, {
-        verifyEntry: request.query?.verifyEntry
+        verifyEntry: Coerce.boolean(request.query?.verifyEntry)
     });
     return {
         headers: {
@@ -920,11 +1025,11 @@ async function auditableItemStreamListEntries(httpRequestContext, componentName,
     const component = ComponentFactory.get(componentName);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const result = await component.getEntries(request.pathParams.id, {
-        conditions: HttpParameterHelper.conditionsFromString(request.query?.conditions),
-        includeDeleted: request.query?.includeDeleted,
-        verifyEntries: request.query?.verifyEntries,
+        conditions: HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
+        verifyEntries: Coerce.boolean(request.query?.verifyEntries),
         order: request.query?.order,
-        pageSize: request.query?.pageSize,
+        pageSize: Coerce.integer(request.query?.pageSize),
         cursor: request.query?.cursor
     });
     return {
@@ -948,10 +1053,10 @@ async function auditableItemStreamListEntryObjects(httpRequestContext, component
     const component = ComponentFactory.get(componentName);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const result = await component.getEntryObjects(request.pathParams.id, {
-        conditions: HttpParameterHelper.conditionsFromString(request.query?.conditions),
-        includeDeleted: request.query?.includeDeleted,
+        conditions: HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
         order: request.query?.order,
-        pageSize: request.query?.pageSize,
+        pageSize: Coerce.integer(request.query?.pageSize),
         cursor: request.query?.cursor
     });
     return {
@@ -1016,6 +1121,11 @@ class AuditableItemStreamService {
      * @internal
      */
     _streamEntryStorage;
+    /**
+     * The event bus component.
+     * @internal
+     */
+    _eventBusComponent;
     /**
      * The default interval for the integrity checks.
      * @internal
@@ -1024,24 +1134,24 @@ class AuditableItemStreamService {
     /**
      * Create a new instance of AuditableItemStreamService.
      * @param options The dependencies for the auditable item stream connector.
-     * @param options.config The configuration for the connector.
-     * @param options.immutableProofComponentType The immutable proof component type, defaults to "immutable-proof".
-     * @param options.streamEntityStorageType The entity storage for stream, defaults to "auditable-item-stream".
-     * @param options.streamEntryEntityStorageType The entity storage for stream entries, defaults to "auditable-item-stream-entry".
      */
     constructor(options) {
         this._immutableProofComponent = ComponentFactory.get(options?.immutableProofComponentType ?? "immutable-proof");
         this._streamStorage = EntityStorageConnectorFactory.get(options?.streamEntityStorageType ?? StringHelper.kebabCase("AuditableItemStream"));
         this._streamEntryStorage = EntityStorageConnectorFactory.get(options?.streamEntryEntityStorageType ??
             StringHelper.kebabCase("AuditableItemStreamEntry"));
+        if (Is.stringValue(options?.eventBusComponentType)) {
+            this._eventBusComponent = ComponentFactory.get(options.eventBusComponentType);
+        }
         this._config = options?.config ?? {};
         this._defaultImmutableInterval = this._config.defaultImmutableInterval ?? 10;
         SchemaOrgDataTypes.registerRedirects();
     }
     /**
      * Create a new stream.
-     * @param streamObject The object for the stream as JSON-LD.
-     * @param entries Entries to store in the stream.
+     * @param stream The stream to create.
+     * @param stream.annotationObject The object for the stream as JSON-LD.
+     * @param stream.entries Entries to store in the stream.
      * @param options Options for creating the stream.
      * @param options.immutableInterval After how many entries do we add immutable checks, defaults to service configured value.
      * A value of 0 will disable integrity checks, 1 will be every item, or any other integer for an interval.
@@ -1049,14 +1159,15 @@ class AuditableItemStreamService {
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns The id of the new stream item.
      */
-    async create(streamObject, entries, options, userIdentity, nodeIdentity) {
+    async create(stream, options, userIdentity, nodeIdentity) {
+        Guards.object(this.CLASS_NAME, "stream", stream);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         try {
-            if (Is.object(streamObject)) {
+            if (Is.object(stream.annotationObject)) {
                 const validationFailures = [];
-                await JsonLdHelper.validate(streamObject, validationFailures);
-                Validation.asValidationError(this.CLASS_NAME, "streamObject", validationFailures);
+                await JsonLdHelper.validate(stream.annotationObject, validationFailures);
+                Validation.asValidationError(this.CLASS_NAME, "stream.annotationObject", validationFailures);
             }
             const id = Converter.bytesToHex(RandomHelper.generate(32), false);
             const context = {
@@ -1075,25 +1186,23 @@ class AuditableItemStreamService {
                 indexCounter: 0,
                 proofId: ""
             };
-            const fullId = new Urn(AuditableItemStreamService.NAMESPACE, id).toString();
             // Create the JSON-LD object we want to use for the proof
             // this is a subset of fixed properties from the stream object.
             const streamModel = await this.streamEntityToJsonLd(ObjectHelper.pick(streamEntity, AuditableItemStreamService._PROOF_KEYS_STREAM));
-            // Use the full id which will appear in the proof
-            streamModel.id = fullId;
             // Create the proof for the stream object
             streamEntity.proofId = await this._immutableProofComponent.create(streamModel, userIdentity, nodeIdentity);
-            if (Is.arrayValue(entries)) {
-                for (const entry of entries) {
+            if (Is.arrayValue(stream.entries)) {
+                for (const entry of stream.entries) {
                     await this.setEntry(context, id, entry);
                 }
             }
             // Add these dynamic properties to the stream object after the proof has been created.
             streamEntity.dateModified = context.now;
-            streamEntity.streamObject = streamObject;
+            streamEntity.annotationObject = stream.annotationObject;
             streamEntity.indexCounter = context.indexCounter;
             await this._streamStorage.set(streamEntity);
-            return fullId;
+            await this._eventBusComponent?.publish(AuditableItemStreamTopics.StreamCreated, { id: streamModel.id });
+            return streamModel.id;
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "createFailed", undefined, error);
@@ -1125,20 +1234,21 @@ class AuditableItemStreamService {
             if (Is.empty(streamEntity)) {
                 throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
             }
+            const verifyStream = options?.verifyStream ?? false;
+            const verifyEntries = options?.verifyEntries ?? false;
             const streamModel = await this.streamEntityToJsonLd(streamEntity);
             if (options?.includeEntries) {
-                const result = await this.findEntries(streamEntity.nodeIdentity, streamModel.id, options?.includeDeleted, options?.verifyEntries);
+                const result = await this.findEntries(streamId, options?.includeDeleted, verifyEntries);
                 streamModel.entries = result.entries;
                 streamModel.cursor = result.cursor;
             }
-            if (options?.verifyStream ?? false) {
-                const fixedStreamModel = await this.streamEntityToJsonLd(ObjectHelper.pick(streamEntity, AuditableItemStreamService._PROOF_KEYS_STREAM));
-                if (Is.stringValue(streamEntity.proofId)) {
-                    streamModel.verification = await this._immutableProofComponent.verify(streamEntity.proofId, fixedStreamModel);
-                }
+            if (verifyStream && Is.stringValue(streamEntity.proofId)) {
+                streamModel.verification = await this._immutableProofComponent.verify(streamEntity.proofId);
+            }
+            if (verifyStream || verifyEntries) {
+                streamModel["@context"].push(ImmutableProofContexts.ContextRoot);
             }
-            const compacted = await JsonLdProcessor.compact(streamModel, streamModel["@context"]);
-            return compacted;
+            return JsonLdProcessor.compact(streamModel, streamModel["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
@@ -1146,44 +1256,79 @@ class AuditableItemStreamService {
     }
     /**
      * Update a stream.
-     * @param id The id of the stream to update.
-     * @param streamObject The object for the stream as JSON-LD.
+     * @param stream The stream to update.
+     * @param stream.id The id of the stream to update.
+     * @param stream.annotationObject The object for the stream as JSON-LD.
      * @param userIdentity The identity to create the auditable item stream operation with.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns Nothing.
      */
-    async update(id, streamObject, userIdentity, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async update(stream, userIdentity, nodeIdentity) {
+        Guards.object(this.CLASS_NAME, "stream", stream);
+        Guards.stringValue(this.CLASS_NAME, "stream.id", stream.id);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(stream.id);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: stream.id
             });
         }
         try {
             const streamId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", stream.id);
             }
-            if (Is.object(streamObject)) {
+            if (Is.object(stream.annotationObject)) {
                 const validationFailures = [];
-                await JsonLdHelper.validate(streamObject, validationFailures);
-                Validation.asValidationError(this.CLASS_NAME, "streamObject", validationFailures);
+                await JsonLdHelper.validate(stream.annotationObject, validationFailures);
+                Validation.asValidationError(this.CLASS_NAME, "stream.annotationObject", validationFailures);
             }
-            if (!ObjectHelper.equal(streamEntity.streamObject, streamObject, false)) {
-                streamEntity.streamObject = streamObject;
+            if (!ObjectHelper.equal(streamEntity.annotationObject, stream.annotationObject, false)) {
+                streamEntity.annotationObject = stream.annotationObject;
                 streamEntity.dateModified = new Date(Date.now()).toISOString();
                 await this._streamStorage.set(streamEntity);
+                await this._eventBusComponent?.publish(AuditableItemStreamTopics.StreamUpdated, { id: stream.id });
             }
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "updateFailed", undefined, error);
         }
     }
+    /**
+     * Delete the stream.
+     * @param id The id of the stream to remove.
+     * @param userIdentity The identity to create the auditable item stream operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns Nothing.
+     */
+    async remove(id, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "id", id);
+        Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        const urnParsed = Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
+            throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemStreamService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const streamId = urnParsed.namespaceSpecific(0);
+            const streamEntity = await this._streamStorage.get(streamId);
+            if (Is.empty(streamEntity)) {
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+            }
+            await this.internalRemoveEntries(streamEntity, false, nodeIdentity);
+            await this._streamStorage.remove(streamEntity.id);
+            await this._eventBusComponent?.publish(AuditableItemStreamTopics.StreamDeleted, { id });
+        }
+        catch (error) {
+            throw new GeneralError(this.CLASS_NAME, "removingFailed", undefined, error);
+        }
+    }
     /**
      * Query all the streams, will not return entries.
      * @param conditions Conditions to use in the query.
@@ -1200,7 +1345,7 @@ class AuditableItemStreamService {
                 "id",
                 "dateCreated",
                 "dateModified",
-                "streamObject"
+                "annotationObject"
             ];
             const orderProperty = orderBy ?? "dateCreated";
             const orderDirection = orderByDirection ?? SortDirection.Descending;
@@ -1222,13 +1367,16 @@ class AuditableItemStreamService {
                 }
             ], propertiesToReturn, cursor, pageSize);
             const list = {
-                "@context": AuditableItemStreamTypes.ContextRoot,
-                type: AuditableItemStreamTypes.StreamList,
-                streams: results.entities.map(e => this.streamEntityToJsonLd(e)),
-                cursor: results.cursor
+                "@context": [
+                    SchemaOrgContexts.ContextRoot,
+                    AuditableItemStreamContexts.ContextRoot,
+                    AuditableItemStreamContexts.ContextRootCommon
+                ],
+                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamList],
+                [SchemaOrgTypes.ItemListElement]: results.entities.map(e => this.streamEntityToJsonLd(e)),
+                [SchemaOrgTypes.NextItem]: results.cursor
             };
-            const compacted = await JsonLdProcessor.compact(list, list["@context"]);
-            return compacted;
+            return JsonLdProcessor.compact(list, list["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "queryingFailed", undefined, error);
@@ -1236,28 +1384,28 @@ class AuditableItemStreamService {
     }
     /**
      * Create an entry in the stream.
-     * @param id The id of the stream to update.
+     * @param streamId The id of the stream to update.
      * @param entryObject The object for the stream as JSON-LD.
      * @param userIdentity The identity to create the auditable item stream operation with.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns The id of the created entry, if not provided.
      */
-    async createEntry(id, entryObject, userIdentity, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async createEntry(streamId, entryObject, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         try {
-            const streamId = urnParsed.namespaceSpecific(0);
-            const streamEntity = await this._streamStorage.get(streamId);
+            const streamIdParts = urnParsed.namespaceSpecific(0);
+            const streamEntity = await this._streamStorage.get(streamIdParts);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamIdParts);
             }
             const context = {
                 now: new Date(Date.now()).toISOString(),
@@ -1272,7 +1420,12 @@ class AuditableItemStreamService {
             streamEntity.dateModified = context.now;
             streamEntity.indexCounter = context.indexCounter;
             await this._streamStorage.set(streamEntity);
-            return new Urn(AuditableItemStreamService.NAMESPACE, [streamEntity.id, createdId]).toString();
+            const fullId = new Urn(AuditableItemStreamService.NAMESPACE, [
+                streamEntity.id,
+                createdId
+            ]).toString();
+            await this._eventBusComponent?.publish(AuditableItemStreamTopics.StreamEntryCreated, { id: streamId, entryId: fullId });
+            return fullId;
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "creatingEntryFailed", undefined, error);
@@ -1280,21 +1433,21 @@ class AuditableItemStreamService {
     }
     /**
      * Get the entry from the stream.
-     * @param id The id of the stream to get.
+     * @param streamId The id of the stream to get.
      * @param entryId The id of the stream entry to get.
      * @param options Additional options for the get operation.
      * @param options.verifyEntry Should the entry be verified, defaults to false.
      * @returns The stream and entries if found.
      * @throws NotFoundError if the stream is not found.
      */
-    async getEntry(id, entryId, options) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async getEntry(streamId, entryId, options) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = Urn.fromValidString(entryId);
@@ -1308,16 +1461,20 @@ class AuditableItemStreamService {
             const streamNamespaceId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
+            const verifyEntry = options?.verifyEntry ?? false;
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
-            const result = await this.findEntry(streamEntity.nodeIdentity, streamEntity.id, entryNamespaceId, options?.verifyEntry);
+            const result = await this.findEntry(streamEntity.nodeIdentity, streamEntity.id, entryNamespaceId, verifyEntry);
             if (Is.empty(result)) {
                 throw new NotFoundError(this.CLASS_NAME, "streamEntryNotFound", entryId);
             }
             const entry = this.streamEntryEntityToJsonLd(result.entity);
-            const compacted = await JsonLdProcessor.compact(entry, entry["@context"]);
-            return compacted;
+            if (verifyEntry) {
+                entry["@context"].push(ImmutableProofContexts.ContextRoot);
+                entry.verification = result.verification;
+            }
+            return JsonLdProcessor.compact(entry, entry["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "gettingEntryFailed", undefined, error);
@@ -1325,19 +1482,19 @@ class AuditableItemStreamService {
     }
     /**
      * Get the entry object from the stream.
-     * @param id The id of the stream to get.
+     * @param streamId The id of the stream to get.
      * @param entryId The id of the stream entry to get.
      * @returns The stream and entries if found.
      * @throws NotFoundError if the stream is not found.
      */
-    async getEntryObject(id, entryId) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async getEntryObject(streamId, entryId) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = Urn.fromValidString(entryId);
@@ -1351,7 +1508,7 @@ class AuditableItemStreamService {
             const streamNamespaceId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
             const result = await this.findEntry(streamEntity.nodeIdentity, streamEntity.id, entryNamespaceId);
@@ -1366,23 +1523,23 @@ class AuditableItemStreamService {
     }
     /**
      * Update an entry in the stream.
-     * @param id The id of the stream to update.
+     * @param streamId The id of the stream to update.
      * @param entryId The id of the entry to update.
      * @param entryObject The object for the entry as JSON-LD.
      * @param userIdentity The identity to create the auditable item stream operation with.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns Nothing.
      */
-    async updateEntry(id, entryId, entryObject, userIdentity, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async updateEntry(streamId, entryId, entryObject, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = Urn.fromValidString(entryId);
@@ -1393,10 +1550,17 @@ class AuditableItemStreamService {
             });
         }
         try {
-            const streamNamespaceId = urnParsed.namespaceSpecific(0);
+            const streamNamespaceId = urnParsed.namespaceMethod();
+            const streamEntryNamespaceId = urnParsedEntry.namespaceMethod();
+            if (streamNamespaceId !== streamEntryNamespaceId) {
+                throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                    streamNamespaceId,
+                    streamEntryNamespaceId
+                });
+            }
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
             const existing = await this.findEntry(nodeIdentity, streamEntity.id, entryNamespaceId);
@@ -1411,12 +1575,13 @@ class AuditableItemStreamService {
                 immutableInterval: streamEntity.immutableInterval
             };
             await this.setEntry(context, streamEntity.id, {
-                ...existing,
+                ...existing.entity,
                 entryObject
             });
             streamEntity.dateModified = context.now;
             streamEntity.indexCounter = context.indexCounter;
             await this._streamStorage.set(streamEntity);
+            await this._eventBusComponent?.publish(AuditableItemStreamTopics.StreamEntryUpdated, { id: streamId, entryId });
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "updatingEntryFailed", undefined, error);
@@ -1424,22 +1589,22 @@ class AuditableItemStreamService {
     }
     /**
      * Delete from the stream.
-     * @param id The id of the stream to update.
-     * @param entryId The id of the entry to delete.
+     * @param streamId The id of the stream to remove from.
+     * @param entryId The id of the entry to remove.
      * @param userIdentity The identity to create the auditable item stream operation with.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns Nothing.
      */
-    async removeEntry(id, entryId, userIdentity, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async removeEntry(streamId, entryId, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = Urn.fromValidString(entryId);
@@ -1450,10 +1615,17 @@ class AuditableItemStreamService {
             });
         }
         try {
-            const streamNamespaceId = urnParsed.namespaceSpecific(0);
+            const streamNamespaceId = urnParsed.namespaceMethod();
+            const streamEntryNamespaceId = urnParsedEntry.namespaceMethod();
+            if (streamNamespaceId !== streamEntryNamespaceId) {
+                throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                    streamNamespaceId,
+                    streamEntryNamespaceId
+                });
+            }
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
             const result = await this.findEntry(streamEntity.nodeIdentity, streamNamespaceId, entryNamespaceId);
@@ -1475,6 +1647,7 @@ class AuditableItemStreamService {
                 streamEntity.dateModified = context.now;
                 streamEntity.indexCounter = context.indexCounter;
                 await this._streamStorage.set(streamEntity);
+                await this._eventBusComponent?.publish(AuditableItemStreamTopics.StreamEntryDeleted, { id: streamId, entryId });
             }
         }
         catch (error) {
@@ -1483,7 +1656,7 @@ class AuditableItemStreamService {
     }
     /**
      * Get the entries for the stream.
-     * @param id The id of the stream to get.
+     * @param streamId The id of the stream to get.
      * @param options Additional options for the get operation.
      * @param options.conditions The conditions to filter the stream.
      * @param options.includeDeleted Whether to include deleted entries, defaults to false.
@@ -1494,34 +1667,37 @@ class AuditableItemStreamService {
      * @returns The stream and entries if found.
      * @throws NotFoundError if the stream is not found.
      */
-    async getEntries(id, options) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
-        const urnParsed = Urn.fromValidString(id);
+    async getEntries(streamId, options) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         try {
             const streamNamespaceId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
-            const result = await this.findEntries(streamEntity.nodeIdentity, streamNamespaceId, options?.includeDeleted, options?.verifyEntries, options?.conditions, options?.order, undefined, options?.pageSize, options?.cursor);
+            const verifyEntries = options?.verifyEntries ?? false;
+            const result = await this.findEntries(streamNamespaceId, options?.includeDeleted, verifyEntries, options?.conditions, options?.order, undefined, options?.pageSize, options?.cursor);
             const list = {
                 "@context": [
-                    AuditableItemStreamTypes.ContextRoot,
-                    ImmutableProofTypes.ContextRoot,
-                    SchemaOrgTypes.ContextRoot
+                    SchemaOrgContexts.ContextRoot,
+                    AuditableItemStreamContexts.ContextRoot,
+                    AuditableItemStreamContexts.ContextRootCommon
                 ],
-                type: AuditableItemStreamTypes.StreamEntryList,
-                entries: result.entries,
-                cursor: result.cursor
+                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                [SchemaOrgTypes.ItemListElement]: result.entries,
+                [SchemaOrgTypes.NextItem]: result.cursor
             };
-            const compacted = await JsonLdProcessor.compact(list, list["@context"]);
-            return compacted;
+            if (verifyEntries) {
+                list["@context"].push(ImmutableProofContexts.ContextRoot);
+            }
+            return JsonLdProcessor.compact(list, list["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "gettingEntriesFailed", undefined, error);
@@ -1529,7 +1705,7 @@ class AuditableItemStreamService {
     }
     /**
      * Get the entry objects for the stream.
-     * @param id The id of the stream to get.
+     * @param streamId The id of the stream to get.
      * @param options Additional options for the get operation.
      * @param options.conditions The conditions to filter the stream.
      * @param options.includeDeleted Whether to include deleted entries, defaults to false.
@@ -1539,86 +1715,65 @@ class AuditableItemStreamService {
      * @returns The stream and entries if found.
      * @throws NotFoundError if the stream is not found.
      */
-    async getEntryObjects(id, options) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
-        const urnParsed = Urn.fromValidString(id);
+    async getEntryObjects(streamId, options) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         try {
             const streamNamespaceId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
-            const result = await this.findEntries(streamEntity.nodeIdentity, streamNamespaceId, options?.includeDeleted, false, options?.conditions, options?.order, undefined, options?.pageSize, options?.cursor);
+            const result = await this.findEntries(streamNamespaceId, options?.includeDeleted, false, options?.conditions, options?.order, undefined, options?.pageSize, options?.cursor);
             const list = {
-                "@context": AuditableItemStreamTypes.ContextRoot,
-                type: AuditableItemStreamTypes.StreamEntryObjectList,
-                entryObjects: result.entries.map(m => m.entryObject),
-                cursor: result.cursor
+                "@context": [
+                    SchemaOrgContexts.ContextRoot,
+                    AuditableItemStreamContexts.ContextRoot,
+                    AuditableItemStreamContexts.ContextRootCommon
+                ],
+                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryObjectList],
+                [SchemaOrgTypes.ItemListElement]: result.entries.map(m => m.entryObject),
+                [SchemaOrgTypes.NextItem]: result.cursor
             };
-            const compacted = await JsonLdProcessor.compact(list, list["@context"]);
-            return compacted;
+            return JsonLdProcessor.compact(list, list["@context"]);
         }
         catch (error) {
             throw new GeneralError(this.CLASS_NAME, "gettingEntryObjectsFailed", undefined, error);
         }
     }
     /**
-     * Remove the immutable storage for the stream and entries.
-     * @param id The id of the stream to remove the storage from.
+     * Remove the verifiable storage for the stream and entries.
+     * @param streamId The id of the stream to remove the storage from.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns Nothing.
      * @throws NotFoundError if the vertex is not found.
      */
-    async removeImmutable(id, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "id", id);
+    async removeVerifiable(streamId, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = Urn.fromValidString(id);
+        const urnParsed = Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         try {
-            const streamId = urnParsed.namespaceSpecific(0);
-            const streamEntity = await this._streamStorage.get(streamId);
+            const streamIdParts = urnParsed.namespaceSpecific(0);
+            const streamEntity = await this._streamStorage.get(streamIdParts);
             if (Is.empty(streamEntity)) {
-                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", id);
-            }
-            if (Is.stringValue(streamEntity.proofId)) {
-                await this._immutableProofComponent.removeImmutable(streamEntity.proofId, nodeIdentity);
-                delete streamEntity.proofId;
-                await this._streamStorage.set(streamEntity);
+                throw new NotFoundError(this.CLASS_NAME, "streamNotFound", streamIdParts);
             }
-            let entriesResult;
-            do {
-                entriesResult = await this._streamEntryStorage.query({
-                    property: "streamId",
-                    value: streamId,
-                    comparison: ComparisonOperator.Equals
-                }, [
-                    {
-                        property: "dateCreated",
-                        sortDirection: SortDirection.Ascending
-                    }
-                ], undefined, entriesResult?.cursor);
-                for (const streamEntry of entriesResult.entities) {
-                    if (Is.stringValue(streamEntry.proofId)) {
-                        await this._immutableProofComponent.removeImmutable(nodeIdentity, streamEntry.proofId);
-                        delete streamEntry.proofId;
-                        await this._streamEntryStorage.set(streamEntry);
-                    }
-                }
-            } while (Is.stringValue(entriesResult.cursor));
+            await this.internalRemoveEntries(streamEntity, true, nodeIdentity);
         }
         catch (error) {
-            throw new GeneralError(this.CLASS_NAME, "removeImmutableFailed", undefined, error);
+            throw new GeneralError(this.CLASS_NAME, "removeVerifiableFailed", undefined, error);
         }
     }
     /**
@@ -1630,17 +1785,17 @@ class AuditableItemStreamService {
     streamEntityToJsonLd(streamEntity) {
         const model = {
             "@context": [
-                AuditableItemStreamTypes.ContextRoot,
-                ImmutableProofTypes.ContextRoot,
-                SchemaOrgTypes.ContextRoot
+                AuditableItemStreamContexts.ContextRoot,
+                AuditableItemStreamContexts.ContextRootCommon,
+                SchemaOrgContexts.ContextRoot
             ],
             type: AuditableItemStreamTypes.Stream,
-            id: streamEntity.id,
+            id: `${AuditableItemStreamService.NAMESPACE}:${streamEntity.id}`,
             dateCreated: streamEntity.dateCreated,
             dateModified: streamEntity.dateModified,
             nodeIdentity: streamEntity.nodeIdentity,
             userIdentity: streamEntity.userIdentity,
-            streamObject: streamEntity.streamObject,
+            annotationObject: streamEntity.annotationObject,
             immutableInterval: streamEntity.immutableInterval,
             proofId: streamEntity.proofId
         };
@@ -1655,9 +1810,9 @@ class AuditableItemStreamService {
     streamEntryEntityToJsonLd(streamEntryEntity) {
         const streamEntryModel = {
             "@context": [
-                AuditableItemStreamTypes.ContextRoot,
-                ImmutableProofTypes.ContextRoot,
-                SchemaOrgTypes.ContextRoot
+                AuditableItemStreamContexts.ContextRoot,
+                AuditableItemStreamContexts.ContextRootCommon,
+                SchemaOrgContexts.ContextRoot
             ],
             type: AuditableItemStreamTypes.StreamEntry,
             id: `${AuditableItemStreamService.NAMESPACE}:${streamEntryEntity.streamId}:${streamEntryEntity.id}`,
@@ -1743,10 +1898,7 @@ class AuditableItemStreamService {
             const entity = result.entities[0];
             let verification;
             if ((verifyEntry ?? false) && Is.stringValue(entity.proofId)) {
-                // Create the JSON-LD object we want to use for the proof
-                // this is a subset of fixed properties from the stream entry object.
-                const streamEntryModel = await this.streamEntryEntityToJsonLd(ObjectHelper.pick(entity, AuditableItemStreamService._PROOF_KEYS_STREAM_ENTRY));
-                verification = await this._immutableProofComponent.verify(entity.proofId, streamEntryModel);
+                verification = await this._immutableProofComponent.verify(entity.proofId);
             }
             return {
                 entity,
@@ -1756,7 +1908,6 @@ class AuditableItemStreamService {
     }
     /**
      * Find stream entries.
-     * @param nodeIdentity The node identity.
      * @param streamId The stream id.
      * @param includeDeleted Should deleted entries be included.
      * @param verifyEntries Should the entries be verified.
@@ -1767,7 +1918,7 @@ class AuditableItemStreamService {
      * @param cursor The cursor.
      * @internal
      */
-    async findEntries(nodeIdentity, streamId, includeDeleted, verifyEntries, conditions, sortDirection, propertiesToReturn, pageSize, cursor) {
+    async findEntries(streamId, includeDeleted, verifyEntries, conditions, sortDirection, propertiesToReturn, pageSize, cursor) {
         const needToVerify = verifyEntries ?? false;
         const combinedConditions = [
             {
@@ -1823,10 +1974,7 @@ class AuditableItemStreamService {
         for (const entry of result.entities) {
             const entryModel = this.streamEntryEntityToJsonLd(entry);
             if (needToVerify && Is.stringValue(entry.proofId)) {
-                // Create the JSON-LD object we want to use for the proof
-                // this is a subset of fixed properties from the stream entry object.
-                const streamEntryModel = await this.streamEntryEntityToJsonLd(ObjectHelper.pick(entry, AuditableItemStreamService._PROOF_KEYS_STREAM_ENTRY));
-                entryModel.verification = await this._immutableProofComponent.verify(entry.proofId, streamEntryModel);
+                entryModel.verification = await this._immutableProofComponent.verify(entry.proofId);
             }
             entryModels.push(entryModel);
         }
@@ -1835,46 +1983,92 @@ class AuditableItemStreamService {
             cursor: returnCursor
         };
     }
+    /**
+     * Remove the verifiable storage for the stream and entries.
+     * @param streamEntity The stream entity.
+     * @param removeOnlyProof Should only the proof be removed.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns Nothing.
+     * @internal
+     */
+    async internalRemoveEntries(streamEntity, removeOnlyProof, nodeIdentity) {
+        if (Is.stringValue(streamEntity.proofId)) {
+            await this._immutableProofComponent.removeVerifiable(streamEntity.proofId, nodeIdentity);
+            delete streamEntity.proofId;
+            await this._streamStorage.set(streamEntity);
+        }
+        const entryIds = [];
+        let entriesResult;
+        do {
+            entriesResult = await this._streamEntryStorage.query({
+                property: "streamId",
+                value: streamEntity.id,
+                comparison: ComparisonOperator.Equals
+            }, [
+                {
+                    property: "dateCreated",
+                    sortDirection: SortDirection.Ascending
+                }
+            ], undefined, entriesResult?.cursor);
+            for (const streamEntry of entriesResult.entities) {
+                entryIds.push(streamEntry.id);
+                if (Is.stringValue(streamEntry.proofId)) {
+                    await this._immutableProofComponent.removeVerifiable(streamEntry.proofId, nodeIdentity);
+                    delete streamEntry.proofId;
+                    // If we are only removing the proof, we need to set the entry
+                    // otherwise the entry is going to be removed later anyway.
+                    if (removeOnlyProof) {
+                        await this._streamEntryStorage.set(streamEntry);
+                    }
+                }
+            }
+        } while (Is.stringValue(entriesResult.cursor));
+        if (!removeOnlyProof) {
+            for (const entryId of entryIds) {
+                await this._streamEntryStorage.remove(entryId);
+            }
+        }
+    }
 }
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Class describing the auditable item stream entry.
+ * Class describing the auditable item stream.
  */
-let AuditableItemStreamEntry = class AuditableItemStreamEntry {
+let AuditableItemStream = class AuditableItemStream {
     /**
-     * The id of the entry.
+     * The id of the stream.
      */
     id;
     /**
-     * The stream that the entry belongs to.
-     */
-    streamId;
-    /**
-     * The date/time of when the entry was created.
+     * The date/time of when the stream was created.
      */
     dateCreated;
     /**
-     * The date/time of when the entry was modified.
+     * The date/time of when the stream was modified.
      */
     dateModified;
     /**
-     * The date/time of when the entry was deleted, as we never actually remove items.
+     * The identity of the node which controls the stream.
      */
-    dateDeleted;
+    nodeIdentity;
     /**
-     * The identity of the user that added the entry.
+     * The identity of the user which created the stream.
      */
     userIdentity;
     /**
-     * Object to associate with the entry as JSON-LD.
+     * Object to associate with the stream as JSON-LD.
      */
-    entryObject;
+    annotationObject;
     /**
-     * The index of the entry in the stream.
+     * The counter for the entry index.
      */
-    index;
+    indexCounter;
+    /**
+     * After how many entries do we add immutable checks.
+     */
+    immutableInterval;
     /**
      * The immutable proof id.
      */
@@ -1883,81 +2077,86 @@ let AuditableItemStreamEntry = class AuditableItemStreamEntry {
 __decorate([
     property({ type: "string", isPrimary: true }),
     __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "id", void 0);
-__decorate([
-    property({ type: "string" }),
-    __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "streamId", void 0);
+], AuditableItemStream.prototype, "id", void 0);
 __decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Ascending }),
+    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
     __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "dateCreated", void 0);
+], AuditableItemStream.prototype, "dateCreated", void 0);
 __decorate([
-    property({ type: "string", format: "date-time" }),
+    property({
+        type: "string",
+        format: "date-time",
+        sortDirection: SortDirection.Descending,
+        optional: true
+    }),
     __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "dateModified", void 0);
+], AuditableItemStream.prototype, "dateModified", void 0);
 __decorate([
-    property({ type: "string", format: "date-time" }),
+    property({ type: "string" }),
     __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "dateDeleted", void 0);
+], AuditableItemStream.prototype, "nodeIdentity", void 0);
 __decorate([
     property({ type: "string" }),
     __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "userIdentity", void 0);
+], AuditableItemStream.prototype, "userIdentity", void 0);
 __decorate([
-    property({ type: "object", itemTypeRef: JsonLdTypes.Object }),
+    property({ type: "object", itemTypeRef: JsonLdTypes.Object, optional: true }),
     __metadata("design:type", Object)
-], AuditableItemStreamEntry.prototype, "entryObject", void 0);
+], AuditableItemStream.prototype, "annotationObject", void 0);
 __decorate([
     property({ type: "integer" }),
     __metadata("design:type", Number)
-], AuditableItemStreamEntry.prototype, "index", void 0);
+], AuditableItemStream.prototype, "indexCounter", void 0);
 __decorate([
-    property({ type: "string" }),
+    property({ type: "integer" }),
+    __metadata("design:type", Number)
+], AuditableItemStream.prototype, "immutableInterval", void 0);
+__decorate([
+    property({ type: "string", optional: true }),
     __metadata("design:type", String)
-], AuditableItemStreamEntry.prototype, "proofId", void 0);
-AuditableItemStreamEntry = __decorate([
+], AuditableItemStream.prototype, "proofId", void 0);
+AuditableItemStream = __decorate([
     entity()
-], AuditableItemStreamEntry);
+], AuditableItemStream);
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Class describing the auditable item stream.
+ * Class describing the auditable item stream entry.
  */
-let AuditableItemStream = class AuditableItemStream {
+let AuditableItemStreamEntry = class AuditableItemStreamEntry {
     /**
-     * The id of the stream.
+     * The id of the entry.
      */
     id;
     /**
-     * The date/time of when the stream was created.
+     * The stream that the entry belongs to.
+     */
+    streamId;
+    /**
+     * The date/time of when the entry was created.
      */
     dateCreated;
     /**
-     * The date/time of when the stream was modified.
+     * The date/time of when the entry was modified.
      */
     dateModified;
     /**
-     * The identity of the node which controls the stream.
+     * The date/time of when the entry was deleted, as we never actually remove items.
      */
-    nodeIdentity;
+    dateDeleted;
     /**
-     * The identity of the user which created the stream.
+     * The identity of the user that added the entry.
      */
     userIdentity;
     /**
-     * Object to associate with the stream as JSON-LD.
-     */
-    streamObject;
-    /**
-     * The counter for the entry index.
+     * Object to associate with the entry as JSON-LD.
      */
-    indexCounter;
+    entryObject;
     /**
-     * After how many entries do we add immutable checks.
+     * The index of the entry in the stream.
      */
-    immutableInterval;
+    index;
     /**
      * The immutable proof id.
      */
@@ -1966,42 +2165,47 @@ let AuditableItemStream = class AuditableItemStream {
 __decorate([
     property({ type: "string", isPrimary: true }),
     __metadata("design:type", String)
-], AuditableItemStream.prototype, "id", void 0);
+], AuditableItemStreamEntry.prototype, "id", void 0);
 __decorate([
-    property({ type: "string", format: "date-time", sortDirection: SortDirection.Descending }),
+    property({ type: "string" }),
     __metadata("design:type", String)
-], AuditableItemStream.prototype, "dateCreated", void 0);
+], AuditableItemStreamEntry.prototype, "streamId", void 0);
 __decorate([
-    property({ type: "string", format: "date-time" }),
+    property({ type: "string", format: "date-time", sortDirection: SortDirection.Ascending }),
     __metadata("design:type", String)
-], AuditableItemStream.prototype, "dateModified", void 0);
+], AuditableItemStreamEntry.prototype, "dateCreated", void 0);
 __decorate([
-    property({ type: "string" }),
+    property({
+        type: "string",
+        format: "date-time",
+        sortDirection: SortDirection.Descending,
+        optional: true
+    }),
     __metadata("design:type", String)
-], AuditableItemStream.prototype, "nodeIdentity", void 0);
+], AuditableItemStreamEntry.prototype, "dateModified", void 0);
+__decorate([
+    property({ type: "string", format: "date-time", optional: true }),
+    __metadata("design:type", String)
+], AuditableItemStreamEntry.prototype, "dateDeleted", void 0);
 __decorate([
     property({ type: "string" }),
     __metadata("design:type", String)
-], AuditableItemStream.prototype, "userIdentity", void 0);
+], AuditableItemStreamEntry.prototype, "userIdentity", void 0);
 __decorate([
     property({ type: "object", itemTypeRef: JsonLdTypes.Object }),
     __metadata("design:type", Object)
-], AuditableItemStream.prototype, "streamObject", void 0);
-__decorate([
-    property({ type: "integer" }),
-    __metadata("design:type", Number)
-], AuditableItemStream.prototype, "indexCounter", void 0);
+], AuditableItemStreamEntry.prototype, "entryObject", void 0);
 __decorate([
     property({ type: "integer" }),
     __metadata("design:type", Number)
-], AuditableItemStream.prototype, "immutableInterval", void 0);
+], AuditableItemStreamEntry.prototype, "index", void 0);
 __decorate([
-    property({ type: "string" }),
+    property({ type: "string", optional: true }),
     __metadata("design:type", String)
-], AuditableItemStream.prototype, "proofId", void 0);
-AuditableItemStream = __decorate([
+], AuditableItemStreamEntry.prototype, "proofId", void 0);
+AuditableItemStreamEntry = __decorate([
     entity()
-], AuditableItemStream);
+], AuditableItemStreamEntry);
 
 const restEntryPoints = [
     {
@@ -2022,4 +2226,4 @@ function initSchema() {
     EntitySchemaFactory.register("AuditableItemStreamEntry", () => EntitySchemaHelper.getSchema(AuditableItemStreamEntry));
 }
 
-export { AuditableItemStream, AuditableItemStreamEntry, AuditableItemStreamService, auditableItemStreamCreate, auditableItemStreamCreateEntry, auditableItemStreamDeleteEntry, auditableItemStreamGet, auditableItemStreamGetEntry, auditableItemStreamGetEntryObject, auditableItemStreamList, auditableItemStreamListEntries, auditableItemStreamListEntryObjects, auditableItemStreamUpdate, auditableItemStreamUpdateEntry, generateRestRoutesAuditableItemStream, initSchema, restEntryPoints, tagsAuditableItemStream };
+export { AuditableItemStream, AuditableItemStreamEntry, AuditableItemStreamService, auditableItemStreamCreate, auditableItemStreamCreateEntry, auditableItemStreamDelete, auditableItemStreamDeleteEntry, auditableItemStreamGet, auditableItemStreamGetEntry, auditableItemStreamGetEntryObject, auditableItemStreamList, auditableItemStreamListEntries, auditableItemStreamListEntryObjects, auditableItemStreamUpdate, auditableItemStreamUpdateEntry, generateRestRoutesAuditableItemStream, initSchema, restEntryPoints, tagsAuditableItemStream };