@twin.org/auditable-item-stream-service 0.0.2-next.5 → 0.0.3-next.10

package/dist/es/auditableItemStreamRoutes.js

@@ -0,0 +1,1283 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+import { HttpParameterHelper } from "@twin.org/api-models";
+import { AuditableItemStreamContexts, AuditableItemStreamTypes } from "@twin.org/auditable-item-stream-models";
+import { Coerce, ComponentFactory, Guards, Is } from "@twin.org/core";
+import { SchemaOrgContexts, SchemaOrgTypes } from "@twin.org/standards-schema-org";
+import { HeaderHelper, HeaderTypes, HttpStatusCode, MimeTypes } from "@twin.org/web";
+/**
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE = "auditableItemStreamRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+export const tagsAuditableItemStream = [
+    {
+        name: "Auditable Item Stream",
+        description: "Endpoints which are modelled to access an auditable item stream contract."
+    }
+];
+/**
+ * The REST routes for auditable item stream.
+ * @param baseRouteName Prefix to prepend to the paths.
+ * @param componentName The name of the component to use in the routes stored in the ComponentFactory.
+ * @returns The generated routes.
+ */
+export function generateRestRoutesAuditableItemStream(baseRouteName, componentName) {
+    const createRoute = {
+        operationId: "auditableItemStreamCreate",
+        summary: "Create a new stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "POST",
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => auditableItemStreamCreate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamCreateRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamCreateRequestExample",
+                    request: {
+                        body: {
+                            annotationObject: {
+                                "@context": "https://schema.org",
+                                "@type": "Note",
+                                content: "This is a simple note"
+                            },
+                            entries: [
+                                {
+                                    entryObject: {
+                                        "@context": "https://schema.org",
+                                        "@type": "Event",
+                                        startDate: "2011-04-09T20:00:00Z",
+                                        description: "A description of the event"
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamCreateResponseExample",
+                        description: "The response when a new stream is created.",
+                        response: {
+                            statusCode: HttpStatusCode.created,
+                            headers: {
+                                [HeaderTypes.Location]: "ais%3A1234567890"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const getRoute = {
+        operationId: "auditableItemStreamGet",
+        summary: "Get a stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:id`,
+        handler: async (httpRequestContext, request) => auditableItemStreamGet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamGetRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamGetRequestExample",
+                    request: {
+                        headers: {
+                            [HeaderTypes.Accept]: MimeTypes.Json
+                        },
+                        pathParams: {
+                            id: "ais:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamGetResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: AuditableItemStreamTypes.Stream,
+                                id: "ais:1234567890",
+                                dateCreated: "2024-08-22T11:55:16.271Z",
+                                dateModified: "2024-08-22T11:55:16.271Z",
+                                annotationObject: {
+                                    "@context": "https://schema.org",
+                                    "@type": "Note",
+                                    content: "This is a simple note"
+                                },
+                                organizationIdentity: "did:iota:1234567890",
+                                proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                immutableInterval: 10,
+                                numberOfItems: 1,
+                                entries: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.StreamEntry,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        index: 0,
+                                        entryObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Event",
+                                            startDate: "2011-04-09T20:00:00Z",
+                                            description: "A description of the event"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemStreamGetResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemStreamJsonLdGetResponseExample",
+                        response: {
+                            headers: {
+                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: AuditableItemStreamTypes.Stream,
+                                id: "ais:1234567890",
+                                dateCreated: "2024-08-22T11:55:16.271Z",
+                                dateModified: "2024-08-22T11:55:16.271Z",
+                                annotationObject: {
+                                    "@context": "https://schema.org",
+                                    "@type": "Note",
+                                    content: "This is a simple note"
+                                },
+                                organizationIdentity: "did:iota:1234567890",
+                                proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                immutableInterval: 10,
+                                numberOfItems: 1,
+                                entries: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.StreamEntry,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        index: 0,
+                                        entryObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Event",
+                                            startDate: "2011-04-09T20:00:00Z",
+                                            description: "A description of the event"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const updateRoute = {
+        operationId: "auditableItemStreamUpdate",
+        summary: "Update a stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "PUT",
+        path: `${baseRouteName}/:id`,
+        handler: async (httpRequestContext, request) => auditableItemStreamUpdate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamUpdateRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamUpdateRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890"
+                        },
+                        body: {
+                            annotationObject: {
+                                "@context": "https://schema.org",
+                                "@type": "Note",
+                                content: "This is a simple note"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    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",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => auditableItemStreamList(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamListRequest",
+            examples: [
+                {
+                    id: "IAuditableItemStreamListAllRequest",
+                    request: {}
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamListResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamListResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.Stream,
+                                        id: "ais:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        dateModified: "2024-08-22T11:55:16.271Z",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Note",
+                                            content: "This is a simple note"
+                                        },
+                                        organizationIdentity: "did:iota:1234567890",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        immutableInterval: 10,
+                                        numberOfItems: 0
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemStreamListResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemStreamJsonLdListResponseExample",
+                        response: {
+                            headers: {
+                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.Stream,
+                                        id: "ais:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        dateModified: "2024-08-22T11:55:16.271Z",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Note",
+                                            content: "This is a simple note"
+                                        },
+                                        organizationIdentity: "did:iota:1234567890",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        immutableInterval: 10,
+                                        numberOfItems: 0
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const createEntryRoute = {
+        operationId: "auditableItemStreamCreateEntry",
+        summary: "Create a new stream entry",
+        tag: tagsAuditableItemStream[0].name,
+        method: "POST",
+        path: `${baseRouteName}/:id/entries`,
+        handler: async (httpRequestContext, request) => auditableItemStreamCreateEntry(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamCreateEntryRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamCreateEntryRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890"
+                        },
+                        body: {
+                            entryObject: {
+                                "@context": "https://schema.org",
+                                "@type": "Event",
+                                startDate: "2011-04-09T20:00:00Z",
+                                description: "A description of the event"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "ICreatedResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamCreateEntryResponseExample",
+                        description: "The response when a new stream entry is created.",
+                        response: {
+                            statusCode: HttpStatusCode.created,
+                            headers: {
+                                [HeaderTypes.Location]: "ais%3A1234567890%3A01010101010"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const deleteEntryRoute = {
+        operationId: "auditableItemStreamDeleteEntry",
+        summary: "Delete an entry from the stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/:id/entries/:entryId`,
+        handler: async (httpRequestContext, request) => auditableItemStreamDeleteEntry(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamDeleteRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamDeleteEntryRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890",
+                            entryId: "ais:1234567890:01010101010"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const updateEntryRoute = {
+        operationId: "auditableItemStreamUpdateEntry",
+        summary: "Update a stream entry",
+        tag: tagsAuditableItemStream[0].name,
+        method: "PUT",
+        path: `${baseRouteName}/:id/entries/:entryId`,
+        handler: async (httpRequestContext, request) => auditableItemStreamUpdateEntry(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamUpdateEntryRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamUpdateRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890",
+                            entryId: "ais:1234567890:01010101010"
+                        },
+                        body: {
+                            entryObject: {
+                                "@context": "https://schema.org",
+                                "@type": "Note",
+                                content: "This is a simple note"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const getEntryRoute = {
+        operationId: "auditableItemStreamGetEntry",
+        summary: "Get a stream entry",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:id/entries/:entryId`,
+        handler: async (httpRequestContext, request) => auditableItemStreamGetEntry(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamGetEntryRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamGetEntryRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890",
+                            entryId: "ais:1234567890:01010101010"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamGetEntryResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamGetEntryResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: AuditableItemStreamTypes.StreamEntry,
+                                id: "tst:1234567890",
+                                dateCreated: "2024-08-22T11:55:16.271Z",
+                                proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                index: 0,
+                                entryObject: {
+                                    "@context": "https://schema.org",
+                                    "@type": "Event",
+                                    startDate: "2011-04-09T20:00:00Z",
+                                    description: "A description of the event"
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemStreamGetEntryResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemStreamJsonLdGetEntryResponseExample",
+                        response: {
+                            headers: {
+                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: AuditableItemStreamTypes.StreamEntry,
+                                id: "tst:1234567890",
+                                dateCreated: "2024-08-22T11:55:16.271Z",
+                                proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                index: 0,
+                                entryObject: {
+                                    "@context": "https://schema.org",
+                                    "@type": "Event",
+                                    startDate: "2011-04-09T20:00:00Z",
+                                    description: "A description of the event"
+                                }
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const getEntryObjectRoute = {
+        operationId: "auditableItemStreamGetEntryObject",
+        summary: "Get a stream entry object",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:id/entries/:entryId/object`,
+        handler: async (httpRequestContext, request) => auditableItemStreamGetEntryObject(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamGetEntryRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamGetEntryObjectRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890",
+                            entryId: "ais:1234567890:01010101010"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamGetEntryObjectResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamGetEntryObjectResponseExample",
+                        response: {
+                            body: {
+                                "@context": "https://schema.org",
+                                "@type": "Event",
+                                startDate: "2011-04-09T20:00:00Z",
+                                description: "A description of the event"
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const listEntriesRoute = {
+        operationId: "auditableItemStreamListEntries",
+        summary: "Get the entry objects in a stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:id/entries`,
+        handler: async (httpRequestContext, request) => auditableItemStreamListEntries(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamListEntriesRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamListEntriesRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamListEntriesResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamListEntriesResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.StreamEntry,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        index: 0,
+                                        entryObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Event",
+                                            startDate: "2011-04-09T20:00:00Z",
+                                            description: "A description of the event"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemStreamListEntriesResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemStreamJsonLdListEntriesResponseExample",
+                        response: {
+                            headers: {
+                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.StreamEntry,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        index: 0,
+                                        entryObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Event",
+                                            startDate: "2011-04-09T20:00:00Z",
+                                            description: "A description of the event"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const listEntriesNoStreamRoute = {
+        operationId: "auditableItemStreamListEntriesNoStream",
+        summary: "Get the entry objects for all streams",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/entries`,
+        handler: async (httpRequestContext, request) => auditableItemStreamListEntriesNoStream(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamListEntriesNoStreamRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamListEntriesNoStreamRequestExample",
+                    request: {}
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamListEntriesResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamListEntriesNoStreamResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.StreamEntry,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        index: 0,
+                                        entryObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Event",
+                                            startDate: "2011-04-09T20:00:00Z",
+                                            description: "A description of the event"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IAuditableItemStreamListEntriesResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "auditableItemStreamJsonLdListEntriesNoStreamResponseExample",
+                        response: {
+                            headers: {
+                                [HeaderTypes.ContentType]: MimeTypes.JsonLd
+                            },
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            AuditableItemStreamContexts.Context,
+                                            AuditableItemStreamContexts.ContextCommon
+                                        ],
+                                        type: AuditableItemStreamTypes.StreamEntry,
+                                        id: "tst:1234567890",
+                                        dateCreated: "2024-08-22T11:55:16.271Z",
+                                        proofId: "0101010101010101010101010101010101010101010101010101010101010101",
+                                        index: 0,
+                                        entryObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "Event",
+                                            startDate: "2011-04-09T20:00:00Z",
+                                            description: "A description of the event"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const listEntryObjectsRoute = {
+        operationId: "auditableItemStreamListEntryObjects",
+        summary: "Get the entry objects in a stream",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:id/entries/objects`,
+        handler: async (httpRequestContext, request) => auditableItemStreamListEntryObjects(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamListEntryObjectsRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamListEntryObjectsRequestExample",
+                    request: {
+                        pathParams: {
+                            id: "ais:1234567890"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamListEntryObjectsResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamListEntryObjectsResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryObjectList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": "https://schema.org",
+                                        "@type": "Event",
+                                        startDate: "2011-04-09T20:00:00Z",
+                                        description: "A description of the event"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const listEntryObjectsNoStreamRoute = {
+        operationId: "auditableItemStreamListEntryObjectsNoStream",
+        summary: "Get the entry objects for all streams",
+        tag: tagsAuditableItemStream[0].name,
+        method: "GET",
+        path: `${baseRouteName}/entries/objects`,
+        handler: async (httpRequestContext, request) => auditableItemStreamListEntryObjectsNoStream(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IAuditableItemStreamListEntryObjectsNoStreamRequest",
+            examples: [
+                {
+                    id: "auditableItemStreamListEntryObjectsNoStreamRequestExample",
+                    request: {}
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IAuditableItemStreamListEntryObjectsResponse",
+                examples: [
+                    {
+                        id: "auditableItemStreamListEntryObjectsNoStreamResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.Context,
+                                    AuditableItemStreamContexts.Context,
+                                    AuditableItemStreamContexts.ContextCommon
+                                ],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemStreamTypes.StreamEntryObjectList],
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": "https://schema.org",
+                                        "@type": "Event",
+                                        startDate: "2011-04-09T20:00:00Z",
+                                        description: "A description of the event"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    return [
+        createRoute,
+        getRoute,
+        updateRoute,
+        deleteRoute,
+        listRoute,
+        createEntryRoute,
+        getEntryRoute,
+        getEntryObjectRoute,
+        deleteEntryRoute,
+        updateEntryRoute,
+        listEntriesRoute,
+        listEntriesNoStreamRoute,
+        listEntryObjectsRoute,
+        listEntryObjectsNoStreamRoute
+    ];
+}
+/**
+ * Create 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.
+ */
+export 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({
+        annotationObject: request.body.annotationObject,
+        entries: request.body.entries
+    }, {
+        immutableInterval: request.body?.immutableInterval
+    });
+    return {
+        statusCode: HttpStatusCode.created,
+        headers: {
+            [HeaderTypes.Location]: id
+        }
+    };
+}
+/**
+ * Get 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.
+ */
+export async function auditableItemStreamGet(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);
+    const result = await component.get(request.pathParams.id, {
+        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: {
+            [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd
+                ? MimeTypes.JsonLd
+                : MimeTypes.Json
+        },
+        body: result
+    };
+}
+/**
+ * Update 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.
+ */
+export 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
+    });
+    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.
+ */
+export 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.remove(request.pathParams.id);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
+/**
+ * Query 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.
+ */
+export async function auditableItemStreamList(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    const hostingComponent = ComponentFactory.get(httpRequestContext.hostingComponentType ?? "hosting");
+    const component = ComponentFactory.get(componentName);
+    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?.limit));
+    const headers = {
+        [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? MimeTypes.JsonLd : MimeTypes.Json
+    };
+    if (Is.stringValue(result.cursor)) {
+        headers[HeaderTypes.Link] = HeaderHelper.createLinkHeader(await hostingComponent.buildPublicUrl(httpRequestContext.serverRequest.url), { cursor: result.cursor }, "next");
+    }
+    return {
+        headers,
+        body: result.entries
+    };
+}
+/**
+ * Create the stream entry.
+ * @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.
+ */
+export async function auditableItemStreamCreateEntry(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    Guards.objectValue(ROUTES_SOURCE, "request.body.entryObject", request.body.entryObject);
+    const component = ComponentFactory.get(componentName);
+    const id = await component.createEntry(request.pathParams.id, request.body.entryObject);
+    return {
+        statusCode: HttpStatusCode.created,
+        headers: {
+            [HeaderTypes.Location]: id
+        }
+    };
+}
+/**
+ * Get 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.
+ */
+export async function auditableItemStreamDeleteEntry(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.stringValue(ROUTES_SOURCE, "request.pathParams.entryId", request.pathParams.entryId);
+    const component = ComponentFactory.get(componentName);
+    await component.removeEntry(request.pathParams.id, request.pathParams.entryId);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
+/**
+ * Update the stream entry.
+ * @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.
+ */
+export async function auditableItemStreamUpdateEntry(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.objectValue(ROUTES_SOURCE, "request.body", request.body);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.entryId", request.pathParams.entryId);
+    Guards.objectValue(ROUTES_SOURCE, "request.body.entryObject", request.body.entryObject);
+    const component = ComponentFactory.get(componentName);
+    await component.updateEntry(request.pathParams.id, request.pathParams.entryId, request.body.entryObject);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
+/**
+ * Get a stream entry.
+ * @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.
+ */
+export async function auditableItemStreamGetEntry(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.stringValue(ROUTES_SOURCE, "request.pathParams.entryId", request.pathParams.entryId);
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getEntry(request.pathParams.id, request.pathParams.entryId, {
+        verifyEntry: Coerce.boolean(request.query?.verifyEntry)
+    });
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd
+                ? MimeTypes.JsonLd
+                : MimeTypes.Json
+        },
+        body: result
+    };
+}
+/**
+ * Get a stream entry object.
+ * @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.
+ */
+export async function auditableItemStreamGetEntryObject(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.stringValue(ROUTES_SOURCE, "request.pathParams.entryId", request.pathParams.entryId);
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getEntryObject(request.pathParams.id, request.pathParams.entryId);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd
+                ? MimeTypes.JsonLd
+                : MimeTypes.Json
+        },
+        body: result
+    };
+}
+/**
+ * Query 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.
+ */
+export async function auditableItemStreamListEntries(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 hostingComponent = ComponentFactory.get(httpRequestContext.hostingComponentType ?? "hosting");
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getEntries(request.pathParams.id, {
+        conditions: HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
+        verifyEntries: Coerce.boolean(request.query?.verifyEntries),
+        order: request.query?.order,
+        limit: Coerce.integer(request.query?.limit),
+        cursor: request.query?.cursor
+    });
+    const headers = {
+        [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? MimeTypes.JsonLd : MimeTypes.Json
+    };
+    if (Is.stringValue(result.cursor)) {
+        headers[HeaderTypes.Link] = HeaderHelper.createLinkHeader(await hostingComponent.buildPublicUrl(httpRequestContext.serverRequest.url), { cursor: result.cursor }, "next");
+    }
+    return {
+        headers,
+        body: result.entries
+    };
+}
+/**
+ * Query 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.
+ */
+export async function auditableItemStreamListEntriesNoStream(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    const hostingComponent = ComponentFactory.get(httpRequestContext.hostingComponentType ?? "hosting");
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getEntries(undefined, {
+        conditions: HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
+        verifyEntries: Coerce.boolean(request.query?.verifyEntries),
+        order: request.query?.order,
+        limit: Coerce.integer(request.query?.limit),
+        cursor: request.query?.cursor
+    });
+    const headers = {
+        [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? MimeTypes.JsonLd : MimeTypes.Json
+    };
+    if (Is.stringValue(result.cursor)) {
+        headers[HeaderTypes.Link] = HeaderHelper.createLinkHeader(await hostingComponent.buildPublicUrl(httpRequestContext.serverRequest.url), { cursor: result.cursor }, "next");
+    }
+    return {
+        headers,
+        body: result.entries
+    };
+}
+/**
+ * Query the stream objects.
+ * @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.
+ */
+export async function auditableItemStreamListEntryObjects(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 hostingComponent = ComponentFactory.get(httpRequestContext.hostingComponentType ?? "hosting");
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getEntryObjects(request.pathParams.id, {
+        conditions: HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
+        order: request.query?.order,
+        limit: Coerce.integer(request.query?.limit),
+        cursor: request.query?.cursor
+    });
+    const headers = {
+        [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? MimeTypes.JsonLd : MimeTypes.Json
+    };
+    if (Is.stringValue(result.cursor)) {
+        headers[HeaderTypes.Link] = HeaderHelper.createLinkHeader(await hostingComponent.buildPublicUrl(httpRequestContext.serverRequest.url), { cursor: result.cursor }, "next");
+    }
+    return {
+        headers,
+        body: result.entries
+    };
+}
+/**
+ * Query the stream objects.
+ * @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.
+ */
+export async function auditableItemStreamListEntryObjectsNoStream(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    const hostingComponent = ComponentFactory.get(httpRequestContext.hostingComponentType ?? "hosting");
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getEntryObjects(undefined, {
+        conditions: HttpParameterHelper.objectFromString(request.query?.conditions),
+        includeDeleted: Coerce.boolean(request.query?.includeDeleted),
+        order: request.query?.order,
+        limit: Coerce.integer(request.query?.limit),
+        cursor: request.query?.cursor
+    });
+    const headers = {
+        [HeaderTypes.ContentType]: request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? MimeTypes.JsonLd : MimeTypes.Json
+    };
+    if (Is.stringValue(result.cursor)) {
+        headers[HeaderTypes.Link] = HeaderHelper.createLinkHeader(await hostingComponent.buildPublicUrl(httpRequestContext.serverRequest.url), { cursor: result.cursor }, "next");
+    }
+    return {
+        headers,
+        body: result.entries
+    };
+}
+//# sourceMappingURL=auditableItemStreamRoutes.js.map