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

package/dist/cjs/index.cjs

@@ -3,9 +3,9 @@
 var apiModels = require('@twin.org/api-models');
 var auditableItemStreamModels = require('@twin.org/auditable-item-stream-models');
 var core = require('@twin.org/core');
+var standardsSchemaOrg = require('@twin.org/standards-schema-org');
 var web = require('@twin.org/web');
 var dataJsonLd = require('@twin.org/data-json-ld');
-var dataSchemaOrg = require('@twin.org/data-schema-org');
 var entity = require('@twin.org/entity');
 var entityStorageModels = require('@twin.org/entity-storage-models');
 var immutableProofModels = require('@twin.org/immutable-proof-models');
@@ -46,15 +46,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"
@@ -115,13 +115,16 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamGetResponseExample",
                         response: {
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: auditableItemStreamModels.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"
                                 },
@@ -131,14 +134,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 immutableInterval: 10,
                                 entries: [
                                     {
-                                        "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: auditableItemStreamModels.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"
@@ -161,13 +167,16 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: auditableItemStreamModels.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"
                                 },
@@ -177,14 +186,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 immutableInterval: 10,
                                 entries: [
                                     {
-                                        "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: auditableItemStreamModels.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"
@@ -218,8 +230,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"
                             }
@@ -237,6 +249,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",
@@ -261,17 +302,24 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamListResponseExample",
                         response: {
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamList,
-                                streams: [
+                                "@context": [
+                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamList],
+                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: auditableItemStreamModels.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"
                                         },
@@ -281,7 +329,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                         immutableInterval: 10
                                     }
                                 ],
-                                cursor: "1"
+                                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -298,17 +346,24 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamList,
-                                streams: [
+                                "@context": [
+                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamList],
+                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: auditableItemStreamModels.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"
                                         },
@@ -318,7 +373,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                         immutableInterval: 10
                                     }
                                 ],
-                                cursor: "1"
+                                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -347,7 +402,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"
@@ -383,7 +438,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",
@@ -424,7 +479,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         },
                         body: {
                             entryObject: {
-                                "@context": "http://schema.org/",
+                                "@context": "https://schema.org",
                                 "@type": "Note",
                                 content: "This is a simple note"
                             }
@@ -471,14 +526,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamGetEntryResponseExample",
                         response: {
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: auditableItemStreamModels.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"
@@ -499,14 +557,17 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                "@context": [
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
                                 type: auditableItemStreamModels.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"
@@ -550,7 +611,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"
@@ -592,25 +653,32 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamListEntriesResponseExample",
                         response: {
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryList,
-                                entries: [
+                                "@context": [
+                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryList],
+                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: auditableItemStreamModels.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"
+                                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -627,25 +695,32 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                                 [web.HeaderTypes.ContentType]: web.MimeTypes.JsonLd
                             },
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryList,
-                                entries: [
+                                "@context": [
+                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryList],
+                                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: [
                                     {
-                                        "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
+                                        "@context": [
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                            auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                        ],
                                         type: auditableItemStreamModels.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"
+                                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -684,17 +759,21 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
                         id: "auditableItemStreamListEntryObjectsResponseExample",
                         response: {
                             body: {
-                                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryObjectList,
-                                entryObjects: [
+                                "@context": [
+                                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                                ],
+                                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryObjectList],
+                                [standardsSchemaOrg.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"
+                                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: "1"
                             }
                         }
                     }
@@ -709,6 +788,7 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
         createRoute,
         getRoute,
         updateRoute,
+        deleteRoute,
         listRoute,
         createEntryRoute,
         getEntryRoute,
@@ -728,8 +808,12 @@ function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
  */
 async function auditableItemStreamCreate(httpRequestContext, componentName, request) {
     core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
     const component = core.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 {
@@ -753,10 +837,10 @@ async function auditableItemStreamGet(httpRequestContext, componentName, request
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
     const component = core.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: core.Coerce.boolean(request.query?.includeEntries),
+        includeDeleted: core.Coerce.boolean(request.query?.includeDeleted),
+        verifyStream: core.Coerce.boolean(request.query?.verifyStream),
+        verifyEntries: core.Coerce.boolean(request.query?.verifyEntries)
     });
     return {
         headers: {
@@ -773,11 +857,32 @@ async function auditableItemStreamGet(httpRequestContext, componentName, request
  * @returns The response object with additional http response properties.
  */
 async function auditableItemStreamUpdate(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    await component.update({
+        id: request.pathParams.id,
+        annotationObject: request.body.annotationObject
+    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: web.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) {
     core.Guards.object(ROUTES_SOURCE, "request", request);
     core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
     core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
     const component = core.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: web.HttpStatusCode.noContent
     };
@@ -794,7 +899,7 @@ async function auditableItemStreamList(httpRequestContext, componentName, reques
     core.Guards.object(ROUTES_SOURCE, "request.query", request.query);
     const component = core.ComponentFactory.get(componentName);
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
-    const result = await component.query(apiModels.HttpParameterHelper.conditionsFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, apiModels.HttpParameterHelper.arrayFromString(request.query?.properties), request.query?.cursor, request.query?.pageSize);
+    const result = await component.query(apiModels.HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.orderBy, request.query?.orderByDirection, apiModels.HttpParameterHelper.arrayFromString(request.query?.properties), request.query?.cursor, core.Coerce.integer(request.query?.pageSize));
     return {
         headers: {
             [web.HeaderTypes.ContentType]: mimeType === "json" ? web.MimeTypes.Json : web.MimeTypes.JsonLd
@@ -877,7 +982,7 @@ async function auditableItemStreamGetEntry(httpRequestContext, componentName, re
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
     const component = core.ComponentFactory.get(componentName);
     const result = await component.getEntry(request.pathParams.id, request.pathParams.entryId, {
-        verifyEntry: request.query?.verifyEntry
+        verifyEntry: core.Coerce.boolean(request.query?.verifyEntry)
     });
     return {
         headers: {
@@ -922,11 +1027,11 @@ async function auditableItemStreamListEntries(httpRequestContext, componentName,
     const component = core.ComponentFactory.get(componentName);
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
     const result = await component.getEntries(request.pathParams.id, {
-        conditions: apiModels.HttpParameterHelper.conditionsFromString(request.query?.conditions),
-        includeDeleted: request.query?.includeDeleted,
-        verifyEntries: request.query?.verifyEntries,
+        conditions: apiModels.HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: core.Coerce.boolean(request.query?.includeDeleted),
+        verifyEntries: core.Coerce.boolean(request.query?.verifyEntries),
         order: request.query?.order,
-        pageSize: request.query?.pageSize,
+        pageSize: core.Coerce.integer(request.query?.pageSize),
         cursor: request.query?.cursor
     });
     return {
@@ -950,10 +1055,10 @@ async function auditableItemStreamListEntryObjects(httpRequestContext, component
     const component = core.ComponentFactory.get(componentName);
     const mimeType = request.headers?.[web.HeaderTypes.Accept] === web.MimeTypes.JsonLd ? "jsonld" : "json";
     const result = await component.getEntryObjects(request.pathParams.id, {
-        conditions: apiModels.HttpParameterHelper.conditionsFromString(request.query?.conditions),
-        includeDeleted: request.query?.includeDeleted,
+        conditions: apiModels.HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: core.Coerce.boolean(request.query?.includeDeleted),
         order: request.query?.order,
-        pageSize: request.query?.pageSize,
+        pageSize: core.Coerce.integer(request.query?.pageSize),
         cursor: request.query?.cursor
     });
     return {
@@ -1018,6 +1123,11 @@ class AuditableItemStreamService {
      * @internal
      */
     _streamEntryStorage;
+    /**
+     * The event bus component.
+     * @internal
+     */
+    _eventBusComponent;
     /**
      * The default interval for the integrity checks.
      * @internal
@@ -1026,24 +1136,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 = core.ComponentFactory.get(options?.immutableProofComponentType ?? "immutable-proof");
         this._streamStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.streamEntityStorageType ?? core.StringHelper.kebabCase("AuditableItemStream"));
         this._streamEntryStorage = entityStorageModels.EntityStorageConnectorFactory.get(options?.streamEntryEntityStorageType ??
             core.StringHelper.kebabCase("AuditableItemStreamEntry"));
+        if (core.Is.stringValue(options?.eventBusComponentType)) {
+            this._eventBusComponent = core.ComponentFactory.get(options.eventBusComponentType);
+        }
         this._config = options?.config ?? {};
         this._defaultImmutableInterval = this._config.defaultImmutableInterval ?? 10;
-        dataSchemaOrg.SchemaOrgDataTypes.registerRedirects();
+        standardsSchemaOrg.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.
@@ -1051,14 +1161,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) {
+        core.Guards.object(this.CLASS_NAME, "stream", stream);
         core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         try {
-            if (core.Is.object(streamObject)) {
+            if (core.Is.object(stream.annotationObject)) {
                 const validationFailures = [];
-                await dataJsonLd.JsonLdHelper.validate(streamObject, validationFailures);
-                core.Validation.asValidationError(this.CLASS_NAME, "streamObject", validationFailures);
+                await dataJsonLd.JsonLdHelper.validate(stream.annotationObject, validationFailures);
+                core.Validation.asValidationError(this.CLASS_NAME, "stream.annotationObject", validationFailures);
             }
             const id = core.Converter.bytesToHex(core.RandomHelper.generate(32), false);
             const context = {
@@ -1077,25 +1188,23 @@ class AuditableItemStreamService {
                 indexCounter: 0,
                 proofId: ""
             };
-            const fullId = new core.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(core.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 (core.Is.arrayValue(entries)) {
-                for (const entry of entries) {
+            if (core.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(auditableItemStreamModels.AuditableItemStreamTopics.StreamCreated, { id: streamModel.id });
+            return streamModel.id;
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "createFailed", undefined, error);
@@ -1127,20 +1236,21 @@ class AuditableItemStreamService {
             if (core.Is.empty(streamEntity)) {
                 throw new core.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(core.ObjectHelper.pick(streamEntity, AuditableItemStreamService._PROOF_KEYS_STREAM));
-                if (core.Is.stringValue(streamEntity.proofId)) {
-                    streamModel.verification = await this._immutableProofComponent.verify(streamEntity.proofId, fixedStreamModel);
-                }
+            if (verifyStream && core.Is.stringValue(streamEntity.proofId)) {
+                streamModel.verification = await this._immutableProofComponent.verify(streamEntity.proofId);
+            }
+            if (verifyStream || verifyEntries) {
+                streamModel["@context"].push(immutableProofModels.ImmutableProofContexts.ContextRoot);
             }
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(streamModel, streamModel["@context"]);
-            return compacted;
+            return dataJsonLd.JsonLdProcessor.compact(streamModel, streamModel["@context"]);
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "getFailed", undefined, error);
@@ -1148,44 +1258,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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async update(stream, userIdentity, nodeIdentity) {
+        core.Guards.object(this.CLASS_NAME, "stream", stream);
+        core.Guards.stringValue(this.CLASS_NAME, "stream.id", stream.id);
         core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(stream.id);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.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 (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", stream.id);
             }
-            if (core.Is.object(streamObject)) {
+            if (core.Is.object(stream.annotationObject)) {
                 const validationFailures = [];
-                await dataJsonLd.JsonLdHelper.validate(streamObject, validationFailures);
-                core.Validation.asValidationError(this.CLASS_NAME, "streamObject", validationFailures);
+                await dataJsonLd.JsonLdHelper.validate(stream.annotationObject, validationFailures);
+                core.Validation.asValidationError(this.CLASS_NAME, "stream.annotationObject", validationFailures);
             }
-            if (!core.ObjectHelper.equal(streamEntity.streamObject, streamObject, false)) {
-                streamEntity.streamObject = streamObject;
+            if (!core.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(auditableItemStreamModels.AuditableItemStreamTopics.StreamUpdated, { id: stream.id });
             }
         }
         catch (error) {
             throw new core.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) {
+        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+        core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        const urnParsed = core.Urn.fromValidString(id);
+        if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
+            throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                namespace: AuditableItemStreamService.NAMESPACE,
+                id
+            });
+        }
+        try {
+            const streamId = urnParsed.namespaceSpecific(0);
+            const streamEntity = await this._streamStorage.get(streamId);
+            if (core.Is.empty(streamEntity)) {
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+            }
+            await this.internalRemoveEntries(streamEntity, false, nodeIdentity);
+            await this._streamStorage.remove(streamEntity.id);
+            await this._eventBusComponent?.publish(auditableItemStreamModels.AuditableItemStreamTopics.StreamDeleted, { id });
+        }
+        catch (error) {
+            throw new core.GeneralError(this.CLASS_NAME, "removingFailed", undefined, error);
+        }
+    }
     /**
      * Query all the streams, will not return entries.
      * @param conditions Conditions to use in the query.
@@ -1202,7 +1347,7 @@ class AuditableItemStreamService {
                 "id",
                 "dateCreated",
                 "dateModified",
-                "streamObject"
+                "annotationObject"
             ];
             const orderProperty = orderBy ?? "dateCreated";
             const orderDirection = orderByDirection ?? entity.SortDirection.Descending;
@@ -1224,13 +1369,16 @@ class AuditableItemStreamService {
                 }
             ], propertiesToReturn, cursor, pageSize);
             const list = {
-                "@context": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamList,
-                streams: results.entities.map(e => this.streamEntityToJsonLd(e)),
-                cursor: results.cursor
+                "@context": [
+                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                ],
+                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamList],
+                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: results.entities.map(e => this.streamEntityToJsonLd(e)),
+                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: results.cursor
             };
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(list, list["@context"]);
-            return compacted;
+            return dataJsonLd.JsonLdProcessor.compact(list, list["@context"]);
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "queryingFailed", undefined, error);
@@ -1238,28 +1386,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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async createEntry(streamId, entryObject, userIdentity, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.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 (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", streamIdParts);
             }
             const context = {
                 now: new Date(Date.now()).toISOString(),
@@ -1274,7 +1422,12 @@ class AuditableItemStreamService {
             streamEntity.dateModified = context.now;
             streamEntity.indexCounter = context.indexCounter;
             await this._streamStorage.set(streamEntity);
-            return new core.Urn(AuditableItemStreamService.NAMESPACE, [streamEntity.id, createdId]).toString();
+            const fullId = new core.Urn(AuditableItemStreamService.NAMESPACE, [
+                streamEntity.id,
+                createdId
+            ]).toString();
+            await this._eventBusComponent?.publish(auditableItemStreamModels.AuditableItemStreamTopics.StreamEntryCreated, { id: streamId, entryId: fullId });
+            return fullId;
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "creatingEntryFailed", undefined, error);
@@ -1282,21 +1435,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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async getEntry(streamId, entryId, options) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         core.Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = core.Urn.fromValidString(entryId);
@@ -1310,16 +1463,20 @@ class AuditableItemStreamService {
             const streamNamespaceId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.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 (core.Is.empty(result)) {
                 throw new core.NotFoundError(this.CLASS_NAME, "streamEntryNotFound", entryId);
             }
             const entry = this.streamEntryEntityToJsonLd(result.entity);
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(entry, entry["@context"]);
-            return compacted;
+            if (verifyEntry) {
+                entry["@context"].push(immutableProofModels.ImmutableProofContexts.ContextRoot);
+                entry.verification = result.verification;
+            }
+            return dataJsonLd.JsonLdProcessor.compact(entry, entry["@context"]);
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "gettingEntryFailed", undefined, error);
@@ -1327,19 +1484,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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async getEntryObject(streamId, entryId) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         core.Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = core.Urn.fromValidString(entryId);
@@ -1353,7 +1510,7 @@ class AuditableItemStreamService {
             const streamNamespaceId = urnParsed.namespaceSpecific(0);
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
             const result = await this.findEntry(streamEntity.nodeIdentity, streamEntity.id, entryNamespaceId);
@@ -1368,23 +1525,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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async updateEntry(streamId, entryId, entryObject, userIdentity, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         core.Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
         core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = core.Urn.fromValidString(entryId);
@@ -1395,10 +1552,17 @@ class AuditableItemStreamService {
             });
         }
         try {
-            const streamNamespaceId = urnParsed.namespaceSpecific(0);
+            const streamNamespaceId = urnParsed.namespaceMethod();
+            const streamEntryNamespaceId = urnParsedEntry.namespaceMethod();
+            if (streamNamespaceId !== streamEntryNamespaceId) {
+                throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                    streamNamespaceId,
+                    streamEntryNamespaceId
+                });
+            }
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
             const existing = await this.findEntry(nodeIdentity, streamEntity.id, entryNamespaceId);
@@ -1413,12 +1577,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(auditableItemStreamModels.AuditableItemStreamTopics.StreamEntryUpdated, { id: streamId, entryId });
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "updatingEntryFailed", undefined, error);
@@ -1426,22 +1591,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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async removeEntry(streamId, entryId, userIdentity, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         core.Guards.stringValue(this.CLASS_NAME, "entryId", entryId);
         core.Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
                 namespace: AuditableItemStreamService.NAMESPACE,
-                id
+                id: streamId
             });
         }
         const urnParsedEntry = core.Urn.fromValidString(entryId);
@@ -1452,10 +1617,17 @@ class AuditableItemStreamService {
             });
         }
         try {
-            const streamNamespaceId = urnParsed.namespaceSpecific(0);
+            const streamNamespaceId = urnParsed.namespaceMethod();
+            const streamEntryNamespaceId = urnParsedEntry.namespaceMethod();
+            if (streamNamespaceId !== streamEntryNamespaceId) {
+                throw new core.GeneralError(this.CLASS_NAME, "namespaceMismatch", {
+                    streamNamespaceId,
+                    streamEntryNamespaceId
+                });
+            }
             const streamEntity = await this._streamStorage.get(streamNamespaceId);
             if (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", streamId);
             }
             const entryNamespaceId = urnParsedEntry.namespaceSpecific(1);
             const result = await this.findEntry(streamEntity.nodeIdentity, streamNamespaceId, entryNamespaceId);
@@ -1477,6 +1649,7 @@ class AuditableItemStreamService {
                 streamEntity.dateModified = context.now;
                 streamEntity.indexCounter = context.indexCounter;
                 await this._streamStorage.set(streamEntity);
+                await this._eventBusComponent?.publish(auditableItemStreamModels.AuditableItemStreamTopics.StreamEntryDeleted, { id: streamId, entryId });
             }
         }
         catch (error) {
@@ -1485,7 +1658,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.
@@ -1496,34 +1669,37 @@ class AuditableItemStreamService {
      * @returns The stream and entries if found.
      * @throws NotFoundError if the stream is not found.
      */
-    async getEntries(id, options) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
-        const urnParsed = core.Urn.fromValidString(id);
+    async getEntries(streamId, options) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.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 (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.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": [
-                    auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                    immutableProofModels.ImmutableProofTypes.ContextRoot,
-                    dataSchemaOrg.SchemaOrgTypes.ContextRoot
+                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
                 ],
-                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryList,
-                entries: result.entries,
-                cursor: result.cursor
+                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryList],
+                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: result.entries,
+                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: result.cursor
             };
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(list, list["@context"]);
-            return compacted;
+            if (verifyEntries) {
+                list["@context"].push(immutableProofModels.ImmutableProofContexts.ContextRoot);
+            }
+            return dataJsonLd.JsonLdProcessor.compact(list, list["@context"]);
         }
         catch (error) {
             throw new core.GeneralError(this.CLASS_NAME, "gettingEntriesFailed", undefined, error);
@@ -1531,7 +1707,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.
@@ -1541,86 +1717,65 @@ class AuditableItemStreamService {
      * @returns The stream and entries if found.
      * @throws NotFoundError if the stream is not found.
      */
-    async getEntryObjects(id, options) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
-        const urnParsed = core.Urn.fromValidString(id);
+    async getEntryObjects(streamId, options) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.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 (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
+                throw new core.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": auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                type: auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryObjectList,
-                entryObjects: result.entries.map(m => m.entryObject),
-                cursor: result.cursor
+                "@context": [
+                    standardsSchemaOrg.SchemaOrgContexts.ContextRoot,
+                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                    auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon
+                ],
+                type: [standardsSchemaOrg.SchemaOrgTypes.ItemList, auditableItemStreamModels.AuditableItemStreamTypes.StreamEntryObjectList],
+                [standardsSchemaOrg.SchemaOrgTypes.ItemListElement]: result.entries.map(m => m.entryObject),
+                [standardsSchemaOrg.SchemaOrgTypes.NextItem]: result.cursor
             };
-            const compacted = await dataJsonLd.JsonLdProcessor.compact(list, list["@context"]);
-            return compacted;
+            return dataJsonLd.JsonLdProcessor.compact(list, list["@context"]);
         }
         catch (error) {
             throw new core.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) {
-        core.Guards.stringValue(this.CLASS_NAME, "id", id);
+    async removeVerifiable(streamId, nodeIdentity) {
+        core.Guards.stringValue(this.CLASS_NAME, "streamId", streamId);
         core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        const urnParsed = core.Urn.fromValidString(id);
+        const urnParsed = core.Urn.fromValidString(streamId);
         if (urnParsed.namespaceIdentifier() !== AuditableItemStreamService.NAMESPACE) {
             throw new core.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 (core.Is.empty(streamEntity)) {
-                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", id);
-            }
-            if (core.Is.stringValue(streamEntity.proofId)) {
-                await this._immutableProofComponent.removeImmutable(streamEntity.proofId, nodeIdentity);
-                delete streamEntity.proofId;
-                await this._streamStorage.set(streamEntity);
+                throw new core.NotFoundError(this.CLASS_NAME, "streamNotFound", streamIdParts);
             }
-            let entriesResult;
-            do {
-                entriesResult = await this._streamEntryStorage.query({
-                    property: "streamId",
-                    value: streamId,
-                    comparison: entity.ComparisonOperator.Equals
-                }, [
-                    {
-                        property: "dateCreated",
-                        sortDirection: entity.SortDirection.Ascending
-                    }
-                ], undefined, entriesResult?.cursor);
-                for (const streamEntry of entriesResult.entities) {
-                    if (core.Is.stringValue(streamEntry.proofId)) {
-                        await this._immutableProofComponent.removeImmutable(nodeIdentity, streamEntry.proofId);
-                        delete streamEntry.proofId;
-                        await this._streamEntryStorage.set(streamEntry);
-                    }
-                }
-            } while (core.Is.stringValue(entriesResult.cursor));
+            await this.internalRemoveEntries(streamEntity, true, nodeIdentity);
         }
         catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "removeImmutableFailed", undefined, error);
+            throw new core.GeneralError(this.CLASS_NAME, "removeVerifiableFailed", undefined, error);
         }
     }
     /**
@@ -1632,17 +1787,17 @@ class AuditableItemStreamService {
     streamEntityToJsonLd(streamEntity) {
         const model = {
             "@context": [
-                auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                immutableProofModels.ImmutableProofTypes.ContextRoot,
-                dataSchemaOrg.SchemaOrgTypes.ContextRoot
+                auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon,
+                standardsSchemaOrg.SchemaOrgContexts.ContextRoot
             ],
             type: auditableItemStreamModels.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
         };
@@ -1657,9 +1812,9 @@ class AuditableItemStreamService {
     streamEntryEntityToJsonLd(streamEntryEntity) {
         const streamEntryModel = {
             "@context": [
-                auditableItemStreamModels.AuditableItemStreamTypes.ContextRoot,
-                immutableProofModels.ImmutableProofTypes.ContextRoot,
-                dataSchemaOrg.SchemaOrgTypes.ContextRoot
+                auditableItemStreamModels.AuditableItemStreamContexts.ContextRoot,
+                auditableItemStreamModels.AuditableItemStreamContexts.ContextRootCommon,
+                standardsSchemaOrg.SchemaOrgContexts.ContextRoot
             ],
             type: auditableItemStreamModels.AuditableItemStreamTypes.StreamEntry,
             id: `${AuditableItemStreamService.NAMESPACE}:${streamEntryEntity.streamId}:${streamEntryEntity.id}`,
@@ -1745,10 +1900,7 @@ class AuditableItemStreamService {
             const entity = result.entities[0];
             let verification;
             if ((verifyEntry ?? false) && core.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(core.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,
@@ -1758,7 +1910,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.
@@ -1769,7 +1920,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 = [
             {
@@ -1825,10 +1976,7 @@ class AuditableItemStreamService {
         for (const entry of result.entities) {
             const entryModel = this.streamEntryEntityToJsonLd(entry);
             if (needToVerify && core.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(core.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);
         }
@@ -1837,46 +1985,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 (core.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: entity.ComparisonOperator.Equals
+            }, [
+                {
+                    property: "dateCreated",
+                    sortDirection: entity.SortDirection.Ascending
+                }
+            ], undefined, entriesResult?.cursor);
+            for (const streamEntry of entriesResult.entities) {
+                entryIds.push(streamEntry.id);
+                if (core.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 (core.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.
  */
-exports.AuditableItemStreamEntry = class AuditableItemStreamEntry {
+exports.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.
      */
@@ -1885,81 +2079,86 @@ exports.AuditableItemStreamEntry = class AuditableItemStreamEntry {
 __decorate([
     entity.property({ type: "string", isPrimary: true }),
     __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "id", void 0);
-__decorate([
-    entity.property({ type: "string" }),
-    __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "streamId", void 0);
+], exports.AuditableItemStream.prototype, "id", void 0);
 __decorate([
-    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Ascending }),
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
     __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "dateCreated", void 0);
+], exports.AuditableItemStream.prototype, "dateCreated", void 0);
 __decorate([
-    entity.property({ type: "string", format: "date-time" }),
+    entity.property({
+        type: "string",
+        format: "date-time",
+        sortDirection: entity.SortDirection.Descending,
+        optional: true
+    }),
     __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "dateModified", void 0);
+], exports.AuditableItemStream.prototype, "dateModified", void 0);
 __decorate([
-    entity.property({ type: "string", format: "date-time" }),
+    entity.property({ type: "string" }),
     __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "dateDeleted", void 0);
+], exports.AuditableItemStream.prototype, "nodeIdentity", void 0);
 __decorate([
     entity.property({ type: "string" }),
     __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "userIdentity", void 0);
+], exports.AuditableItemStream.prototype, "userIdentity", void 0);
 __decorate([
-    entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.Object }),
+    entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.Object, optional: true }),
     __metadata("design:type", Object)
-], exports.AuditableItemStreamEntry.prototype, "entryObject", void 0);
+], exports.AuditableItemStream.prototype, "annotationObject", void 0);
 __decorate([
     entity.property({ type: "integer" }),
     __metadata("design:type", Number)
-], exports.AuditableItemStreamEntry.prototype, "index", void 0);
+], exports.AuditableItemStream.prototype, "indexCounter", void 0);
 __decorate([
-    entity.property({ type: "string" }),
+    entity.property({ type: "integer" }),
+    __metadata("design:type", Number)
+], exports.AuditableItemStream.prototype, "immutableInterval", void 0);
+__decorate([
+    entity.property({ type: "string", optional: true }),
     __metadata("design:type", String)
-], exports.AuditableItemStreamEntry.prototype, "proofId", void 0);
-exports.AuditableItemStreamEntry = __decorate([
+], exports.AuditableItemStream.prototype, "proofId", void 0);
+exports.AuditableItemStream = __decorate([
     entity.entity()
-], exports.AuditableItemStreamEntry);
+], exports.AuditableItemStream);
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
- * Class describing the auditable item stream.
+ * Class describing the auditable item stream entry.
  */
-exports.AuditableItemStream = class AuditableItemStream {
+exports.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.
      */
@@ -1968,42 +2167,47 @@ exports.AuditableItemStream = class AuditableItemStream {
 __decorate([
     entity.property({ type: "string", isPrimary: true }),
     __metadata("design:type", String)
-], exports.AuditableItemStream.prototype, "id", void 0);
+], exports.AuditableItemStreamEntry.prototype, "id", void 0);
 __decorate([
-    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Descending }),
+    entity.property({ type: "string" }),
     __metadata("design:type", String)
-], exports.AuditableItemStream.prototype, "dateCreated", void 0);
+], exports.AuditableItemStreamEntry.prototype, "streamId", void 0);
 __decorate([
-    entity.property({ type: "string", format: "date-time" }),
+    entity.property({ type: "string", format: "date-time", sortDirection: entity.SortDirection.Ascending }),
     __metadata("design:type", String)
-], exports.AuditableItemStream.prototype, "dateModified", void 0);
+], exports.AuditableItemStreamEntry.prototype, "dateCreated", void 0);
 __decorate([
-    entity.property({ type: "string" }),
+    entity.property({
+        type: "string",
+        format: "date-time",
+        sortDirection: entity.SortDirection.Descending,
+        optional: true
+    }),
     __metadata("design:type", String)
-], exports.AuditableItemStream.prototype, "nodeIdentity", void 0);
+], exports.AuditableItemStreamEntry.prototype, "dateModified", void 0);
+__decorate([
+    entity.property({ type: "string", format: "date-time", optional: true }),
+    __metadata("design:type", String)
+], exports.AuditableItemStreamEntry.prototype, "dateDeleted", void 0);
 __decorate([
     entity.property({ type: "string" }),
     __metadata("design:type", String)
-], exports.AuditableItemStream.prototype, "userIdentity", void 0);
+], exports.AuditableItemStreamEntry.prototype, "userIdentity", void 0);
 __decorate([
     entity.property({ type: "object", itemTypeRef: dataJsonLd.JsonLdTypes.Object }),
     __metadata("design:type", Object)
-], exports.AuditableItemStream.prototype, "streamObject", void 0);
-__decorate([
-    entity.property({ type: "integer" }),
-    __metadata("design:type", Number)
-], exports.AuditableItemStream.prototype, "indexCounter", void 0);
+], exports.AuditableItemStreamEntry.prototype, "entryObject", void 0);
 __decorate([
     entity.property({ type: "integer" }),
     __metadata("design:type", Number)
-], exports.AuditableItemStream.prototype, "immutableInterval", void 0);
+], exports.AuditableItemStreamEntry.prototype, "index", void 0);
 __decorate([
-    entity.property({ type: "string" }),
+    entity.property({ type: "string", optional: true }),
     __metadata("design:type", String)
-], exports.AuditableItemStream.prototype, "proofId", void 0);
-exports.AuditableItemStream = __decorate([
+], exports.AuditableItemStreamEntry.prototype, "proofId", void 0);
+exports.AuditableItemStreamEntry = __decorate([
     entity.entity()
-], exports.AuditableItemStream);
+], exports.AuditableItemStreamEntry);
 
 const restEntryPoints = [
     {
@@ -2027,6 +2231,7 @@ function initSchema() {
 exports.AuditableItemStreamService = AuditableItemStreamService;
 exports.auditableItemStreamCreate = auditableItemStreamCreate;
 exports.auditableItemStreamCreateEntry = auditableItemStreamCreateEntry;
+exports.auditableItemStreamDelete = auditableItemStreamDelete;
 exports.auditableItemStreamDeleteEntry = auditableItemStreamDeleteEntry;
 exports.auditableItemStreamGet = auditableItemStreamGet;
 exports.auditableItemStreamGetEntry = auditableItemStreamGetEntry;