@twin.org/document-management-service 0.0.1-next.8 → 0.0.1

package/dist/esm/index.mjs

@@ -1,17 +1,14 @@
-import { HttpParameterHelper } from '@twin.org/api-models';
-import { Guards, ComponentFactory, Converter, Coerce, Is, ObjectHelper, BaseError, GeneralError, Urn, NotFoundError } from '@twin.org/core';
+import { AuditableItemGraphTypes, AuditableItemGraphContexts } from '@twin.org/auditable-item-graph-models';
+import { Guards, ComponentFactory, Converter, Coerce, Is, BaseError, GeneralError, Urn, NotFoundError, ObjectHelper } from '@twin.org/core';
 import { DocumentTypes, DocumentContexts } from '@twin.org/document-management-models';
-import { SchemaOrgContexts, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
+import { SchemaOrgContexts, SchemaOrgTypes, SchemaOrgDataTypes } from '@twin.org/standards-schema-org';
 import { UneceDocumentCodes } from '@twin.org/standards-unece';
 import { HttpStatusCode, HeaderTypes, MimeTypes } from '@twin.org/web';
 import { AttestationContexts } from '@twin.org/attestation-models';
-import { AuditableItemGraphTypes, AuditableItemGraphContexts } from '@twin.org/auditable-item-graph-models';
 import { BlobStorageContexts } from '@twin.org/blob-storage-models';
 import { Sha256 } from '@twin.org/crypto';
 import { JsonLdProcessor } from '@twin.org/data-json-ld';
 
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
  * The source used when communicating about these routes.
  */
@@ -32,22 +29,19 @@ const tagsDocumentManagement = [
  * @returns The generated routes.
  */
 function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
-    const documentManagementSetRoute = {
+    const documentManagementCreateRoute = {
         operationId: "DocumentManagementSet",
         summary: "Store a document in an auditable item graph vertex and add its content to blob storage.",
         tag: tagsDocumentManagement[0].name,
         method: "POST",
-        path: `${baseRouteName}/:auditableItemGraphId`,
-        handler: async (httpRequestContext, request) => documentManagementSet(httpRequestContext, componentName, request),
+        path: `${baseRouteName}/`,
+        handler: async (httpRequestContext, request) => documentManagementCreate(httpRequestContext, componentName, request),
         requestType: {
-            type: "IDocumentManagementSetRequest",
+            type: "IDocumentManagementCreateRequest",
             examples: [
                 {
-                    id: "DocumentManagementSetRequestExample",
+                    id: "DocumentManagementCreateRequestExample",
                     request: {
-                        pathParams: {
-                            auditableItemGraphId: "aig:123456"
-                        },
                         body: {
                             documentId: "2721000",
                             documentIdFormat: "bol",
@@ -69,14 +63,56 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                 type: "ICreatedResponse",
                 examples: [
                     {
-                        id: "DocumentManagementSetResponseExample",
+                        id: "DocumentManagementCreateResponseExample",
                         response: {
                             statusCode: HttpStatusCode.created,
                             headers: {
-                                [HeaderTypes.Location]: "documents:123456:705:2721000"
+                                [HeaderTypes.Location]: "aig:123456"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const documentManagementUpdateRoute = {
+        operationId: "DocumentManagementUpdate",
+        summary: "Update a document in an auditable item graph vertex and add its content to blob storage.",
+        tag: tagsDocumentManagement[0].name,
+        method: "PUT",
+        path: `${baseRouteName}/:auditableItemGraphDocumentId`,
+        handler: async (httpRequestContext, request) => documentManagementUpdate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementUpdateRequest",
+            examples: [
+                {
+                    id: "DocumentManagementUpdateRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphDocumentId: "aig:123456"
+                        },
+                        body: {
+                            blob: "SGVsbG8gV29ybGQ=",
+                            annotationObject: {
+                                "@context": "https://schema.org",
+                                "@type": "DigitalDocument",
+                                name: "myfile.pdf"
                             }
                         }
                     }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementCreateResponseExample",
+                        response: {
+                            statusCode: HttpStatusCode.noContent
+                        }
+                    }
                 ]
             }
         ]
@@ -86,7 +122,7 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
         summary: "Get the data for a document from document management",
         tag: tagsDocumentManagement[0].name,
         method: "GET",
-        path: `${baseRouteName}/:auditableItemGraphId/:documentId`,
+        path: `${baseRouteName}/:auditableItemGraphDocumentId`,
         handler: async (httpRequestContext, request) => documentManagementGet(httpRequestContext, componentName, request),
         requestType: {
             type: "IDocumentManagementGetRequest",
@@ -95,8 +131,7 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                     id: "DocumentManagementGetRequestExample",
                     request: {
                         pathParams: {
-                            auditableItemGraphId: "aig:1234",
-                            documentId: "documents:123456:705:2721000"
+                            auditableItemGraphDocumentId: "aig:123456"
                         }
                     }
                 }
@@ -108,6 +143,120 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                 examples: [
                     {
                         id: "DocumentManagementGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    DocumentContexts.ContextRoot,
+                                    DocumentContexts.ContextRootCommon
+                                ],
+                                type: SchemaOrgTypes.ItemList,
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            DocumentContexts.ContextRoot,
+                                            DocumentContexts.ContextRootCommon,
+                                            SchemaOrgContexts.ContextRoot
+                                        ],
+                                        type: DocumentTypes.Document,
+                                        id: "2721000:0",
+                                        documentId: "2721000",
+                                        documentIdFormat: "bol",
+                                        documentCode: UneceDocumentCodes.BillOfLading,
+                                        documentRevision: 0,
+                                        blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
+                                        blobHash: "sha256:123456",
+                                        dateCreated: "2024-01-01T00:00:00Z",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "DigitalDocument",
+                                            name: "myfile.pdf"
+                                        },
+                                        nodeIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363",
+                                        userIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "IDocumentManagementGetResponse",
+                mimeType: MimeTypes.JsonLd,
+                examples: [
+                    {
+                        id: "DocumentManagementGetResponseExample",
+                        response: {
+                            body: {
+                                "@context": [
+                                    SchemaOrgContexts.ContextRoot,
+                                    DocumentContexts.ContextRoot,
+                                    DocumentContexts.ContextRootCommon
+                                ],
+                                type: SchemaOrgTypes.ItemList,
+                                [SchemaOrgTypes.ItemListElement]: [
+                                    {
+                                        "@context": [
+                                            DocumentContexts.ContextRoot,
+                                            DocumentContexts.ContextRootCommon,
+                                            SchemaOrgContexts.ContextRoot
+                                        ],
+                                        type: DocumentTypes.Document,
+                                        id: "2721000:0",
+                                        documentId: "2721000",
+                                        documentIdFormat: "bol",
+                                        documentCode: UneceDocumentCodes.BillOfLading,
+                                        documentRevision: 0,
+                                        blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
+                                        blobHash: "sha256:123456",
+                                        dateCreated: "2024-01-01T00:00:00Z",
+                                        annotationObject: {
+                                            "@context": "https://schema.org",
+                                            "@type": "DigitalDocument",
+                                            name: "myfile.pdf"
+                                        },
+                                        nodeIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363",
+                                        userIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363"
+                                    }
+                                ]
+                            }
+                        }
+                    }
+                ]
+            },
+            {
+                type: "INotFoundResponse"
+            }
+        ]
+    };
+    const documentManagementGetRevisionRoute = {
+        operationId: "DocumentManagementGetRevision",
+        summary: "Get the data for a document revision from document management",
+        tag: tagsDocumentManagement[0].name,
+        method: "GET",
+        path: `${baseRouteName}/:auditableItemGraphDocumentId/:revision`,
+        handler: async (httpRequestContext, request) => documentManagementGetRevision(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IDocumentManagementGetRequest",
+            examples: [
+                {
+                    id: "DocumentManagementGetRevisionRequestExample",
+                    request: {
+                        pathParams: {
+                            auditableItemGraphDocumentId: "aig:123456",
+                            revision: "1"
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IDocumentManagementGetRevisionResponse",
+                examples: [
+                    {
+                        id: "DocumentManagementGetRevisionResponseExample",
                         response: {
                             body: {
                                 "@context": [
@@ -116,11 +265,11 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                                     SchemaOrgContexts.ContextRoot
                                 ],
                                 type: DocumentTypes.Document,
-                                id: "documents:705:2721000:rev-0",
+                                id: "2721000:0",
                                 documentId: "2721000",
                                 documentIdFormat: "bol",
                                 documentCode: UneceDocumentCodes.BillOfLading,
-                                documentRevision: 0,
+                                documentRevision: 1,
                                 blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
                                 blobHash: "sha256:123456",
                                 dateCreated: "2024-01-01T00:00:00Z",
@@ -137,11 +286,11 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                 ]
             },
             {
-                type: "IDocumentManagementGetResponse",
+                type: "IDocumentManagementGetRevisionResponse",
                 mimeType: MimeTypes.JsonLd,
                 examples: [
                     {
-                        id: "DocumentManagementGetResponseExample",
+                        id: "DocumentManagementGetRevisionResponseExample",
                         response: {
                             body: {
                                 "@context": [
@@ -150,11 +299,11 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                                     SchemaOrgContexts.ContextRoot
                                 ],
                                 type: DocumentTypes.Document,
-                                id: "documents:705:2721000:rev-0",
+                                id: "2721000:0",
                                 documentId: "2721000",
                                 documentIdFormat: "bol",
                                 documentCode: UneceDocumentCodes.BillOfLading,
-                                documentRevision: 0,
+                                documentRevision: 1,
                                 blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
                                 blobHash: "sha256:123456",
                                 dateCreated: "2024-01-01T00:00:00Z",
@@ -175,12 +324,12 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const documentManagementRemoveRoute = {
+    const documentManagementRemoveRevisionRoute = {
         operationId: "DocumentManagementRemove",
         summary: "Remove an document from an auditable item graph vertex",
         tag: tagsDocumentManagement[0].name,
         method: "DELETE",
-        path: `${baseRouteName}/:auditableItemGraphId/:documentId`,
+        path: `${baseRouteName}/:auditableItemGraphDocumentId/:revision`,
         handler: async (httpRequestContext, request) => documentManagementRemove(httpRequestContext, componentName, request),
         requestType: {
             type: "IDocumentManagementRemoveRequest",
@@ -189,8 +338,8 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                     id: "DocumentManagementRemoveRequestExample",
                     request: {
                         pathParams: {
-                            auditableItemGraphId: "aig:1234",
-                            documentId: "documents:123456:705:2721000"
+                            auditableItemGraphDocumentId: "aig:1234",
+                            revision: "1"
                         }
                     }
                 }
@@ -210,7 +359,7 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
         summary: "Query the items from an auditable item graph vertex",
         tag: tagsDocumentManagement[0].name,
         method: "GET",
-        path: `${baseRouteName}/:auditableItemGraphId`,
+        path: `${baseRouteName}/`,
         handler: async (httpRequestContext, request) => documentManagementQuery(httpRequestContext, componentName, request),
         requestType: {
             type: "IDocumentManagementQueryRequest",
@@ -218,8 +367,8 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                 {
                     id: "DocumentManagementQueryRequestExample",
                     request: {
-                        pathParams: {
-                            auditableItemGraphId: "aig:123456"
+                        query: {
+                            documentId: "2721000"
                         }
                     }
                 }
@@ -233,71 +382,54 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
                         id: "DocumentManagementQueryResponseExample",
                         response: {
                             body: {
-                                "@context": [DocumentContexts.ContextRoot, DocumentContexts.ContextRootCommon],
-                                type: DocumentTypes.DocumentList,
-                                documents: [
+                                "@context": [SchemaOrgContexts.ContextRoot, AuditableItemGraphContexts.ContextRoot],
+                                type: [SchemaOrgTypes.ItemList, AuditableItemGraphTypes.VertexList],
+                                [SchemaOrgTypes.ItemListElement]: [
                                     {
                                         "@context": [
-                                            DocumentContexts.ContextRoot,
-                                            DocumentContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
+                                            AuditableItemGraphContexts.ContextRoot,
+                                            AuditableItemGraphContexts.ContextRootCommon
                                         ],
-                                        type: DocumentTypes.Document,
-                                        id: "documents:705:2721000:rev-0",
-                                        documentId: "2721000",
-                                        documentIdFormat: "bol",
-                                        documentCode: UneceDocumentCodes.BillOfLading,
-                                        documentRevision: 0,
-                                        blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        blobHash: "sha256:123456",
-                                        dateCreated: "2024-01-01T00:00:00Z",
-                                        annotationObject: {
-                                            "@context": "https://schema.org",
-                                            "@type": "DigitalDocument",
-                                            name: "myfile.pdf"
-                                        },
-                                        nodeIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363",
-                                        userIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363"
-                                    }
-                                ]
-                            }
-                        }
-                    }
-                ]
-            },
-            {
-                type: "IDocumentManagementQueryResponse",
-                mimeType: MimeTypes.JsonLd,
-                examples: [
-                    {
-                        id: "DocumentManagementListResponseJsonLdExample",
-                        response: {
-                            body: {
-                                "@context": [DocumentContexts.ContextRoot, DocumentContexts.ContextRootCommon],
-                                type: DocumentTypes.DocumentList,
-                                documents: [
-                                    {
-                                        "@context": [
-                                            DocumentContexts.ContextRoot,
-                                            DocumentContexts.ContextRootCommon,
-                                            SchemaOrgContexts.ContextRoot
+                                        id: "aig:c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7c7",
+                                        type: AuditableItemGraphTypes.Vertex,
+                                        dateCreated: "2024-08-22T04:13:20.000Z",
+                                        aliases: [
+                                            {
+                                                "@context": [AuditableItemGraphContexts.ContextRoot],
+                                                id: "test-id-0",
+                                                type: AuditableItemGraphTypes.Alias,
+                                                dateCreated: "2024-08-22T04:13:20.000Z"
+                                            }
                                         ],
-                                        type: DocumentTypes.Document,
-                                        id: "documents:705:2721000:rev-0",
-                                        documentId: "2721000",
-                                        documentIdFormat: "bol",
-                                        documentCode: UneceDocumentCodes.BillOfLading,
-                                        documentRevision: 0,
-                                        blobStorageId: "blob-memory:c57d94b088f4c6d2cb32ded014813d0c786aa00134c8ee22f84b1e2545602a70",
-                                        blobHash: "sha256:123456",
-                                        dateCreated: "2024-01-01T00:00:00Z",
-                                        annotationObject: {
-                                            "@context": "https://schema.org",
-                                            "@type": "DigitalDocument",
-                                            name: "myfile.pdf"
-                                        },
-                                        nodeIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363",
-                                        userIdentity: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363"
+                                        resources: [
+                                            {
+                                                "@context": AuditableItemGraphContexts.ContextRoot,
+                                                type: AuditableItemGraphTypes.Resource,
+                                                dateCreated: "2024-08-22T04:13:20.000Z",
+                                                resourceObject: {
+                                                    "@context": [
+                                                        "https://schema.twindev.org/documents/",
+                                                        "https://schema.twindev.org/common/",
+                                                        "https://schema.org"
+                                                    ],
+                                                    type: "Document",
+                                                    id: "test-id-0:0",
+                                                    documentId: "test-id-0",
+                                                    documentCode: "unece:DocumentCodeList#705",
+                                                    documentRevision: 0,
+                                                    annotationObject: {
+                                                        "@context": "https://schema.org",
+                                                        type: "DigitalDocument",
+                                                        name: "bill-of-lading"
+                                                    },
+                                                    blobHash: "sha256:E3Duqrp6bHojSx+CzDttAToAiP1eFkCDAPBbKLABVGM=",
+                                                    blobStorageId: "blob:memory:1370eeaaba7a6c7a234b1f82cc3b6d013a0088fd5e16408300f05b28b0015463",
+                                                    dateCreated: "2024-08-22T04:13:20.000Z",
+                                                    nodeIdentity: "did:entity-storage:0x0101010101010101010101010101010101010101010101010101010101010101",
+                                                    userIdentity: "did:entity-storage:0x0404040404040404040404040404040404040404040404040404040404040404"
+                                                }
+                                            }
+                                        ]
                                     }
                                 ]
                             }
@@ -308,29 +440,29 @@ function generateRestRoutesDocumentManagement(baseRouteName, componentName) {
         ]
     };
     return [
-        documentManagementSetRoute,
+        documentManagementCreateRoute,
+        documentManagementUpdateRoute,
         documentManagementGetRoute,
-        documentManagementRemoveRoute,
+        documentManagementGetRevisionRoute,
+        documentManagementRemoveRevisionRoute,
         documentManagementQueryRoute
     ];
 }
 /**
- * Set a document in to an auditable item graph vertex.
+ * Create a document as an auditable item graph vertex.
  * @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 documentManagementSet(httpRequestContext, componentName, request) {
+async function documentManagementCreate(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphId", request.pathParams.auditableItemGraphId);
     Guards.object(ROUTES_SOURCE, "request.body", request.body);
     Guards.stringBase64(ROUTES_SOURCE, "request.body.blob", request.body.blob);
     const component = ComponentFactory.get(componentName);
-    const id = await component.set(request.pathParams.auditableItemGraphId, request.body.documentId, request.body.documentIdFormat, request.body.documentCode, Converter.base64ToBytes(request.body.blob), request.body.annotationObject, {
+    const id = await component.create(request.body.documentId, request.body.documentIdFormat, request.body.documentCode, Converter.base64ToBytes(request.body.blob), request.body.annotationObject, request.body.auditableItemGraphEdges, {
         createAttestation: request.body.createAttestation,
-        includeIdAsAlias: request.body.includeIdAsAlias,
+        addAlias: request.body.addAlias,
         aliasAnnotationObject: request.body.aliasAnnotationObject
     }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
@@ -350,17 +482,17 @@ async function documentManagementSet(httpRequestContext, componentName, request)
 async function documentManagementGet(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
     Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphId", request.pathParams.auditableItemGraphId);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.documentId", request.pathParams.documentId);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const component = ComponentFactory.get(componentName);
-    const result = await component.get(request.pathParams.auditableItemGraphId, request.pathParams.documentId, {
+    const result = await component.get(request.pathParams.auditableItemGraphDocumentId, {
         includeBlobStorageMetadata: Coerce.boolean(request.query?.includeBlobStorageMetadata),
         includeBlobStorageData: Coerce.boolean(request.query?.includeBlobStorageData),
         includeAttestation: Coerce.boolean(request.query?.includeAttestation),
         includeRemoved: Coerce.boolean(request.query?.includeRemoved),
-        maxRevisionCount: Coerce.integer(request.query?.maxRevisionCount)
-    }, request.query?.revisionCursor, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+        extractRuleGroupId: request.query?.extractRuleGroupId,
+        extractMimeType: request.query?.extractMimeType
+    }, request.query?.cursor, Coerce.integer(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         headers: {
             [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
@@ -368,6 +500,52 @@ async function documentManagementGet(httpRequestContext, componentName, request)
         body: result
     };
 }
+/**
+ * Get the document revision from the auditable item graph vertex.
+ * @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 documentManagementGetRevision(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
+    const revision = Coerce.integer(request.pathParams.revision);
+    Guards.integer(ROUTES_SOURCE, "revision", revision);
+    const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
+    const component = ComponentFactory.get(componentName);
+    const result = await component.getRevision(request.pathParams.auditableItemGraphDocumentId, revision, {
+        includeBlobStorageMetadata: Coerce.boolean(request.query?.includeBlobStorageMetadata),
+        includeBlobStorageData: Coerce.boolean(request.query?.includeBlobStorageData),
+        includeAttestation: Coerce.boolean(request.query?.includeAttestation),
+        extractRuleGroupId: request.query?.extractRuleGroupId,
+        extractMimeType: request.query?.extractMimeType
+    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        headers: {
+            [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
+        },
+        body: result
+    };
+}
+/**
+ * Update the document from the auditable item graph vertex.
+ * @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 documentManagementUpdate(httpRequestContext, componentName, request) {
+    Guards.object(ROUTES_SOURCE, "request", request);
+    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
+    const component = ComponentFactory.get(componentName);
+    await component.update(request.pathParams.auditableItemGraphDocumentId, Is.stringValue(request.body.blob) ? Converter.base64ToBytes(request.body.blob) : undefined, request.body.annotationObject, request.body.auditableItemGraphEdges, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    return {
+        statusCode: HttpStatusCode.noContent
+    };
+}
 /**
  * Remove the document from the auditable item graph vertex.
  * @param httpRequestContext The request context for the API.
@@ -378,12 +556,11 @@ async function documentManagementGet(httpRequestContext, componentName, request)
 async function documentManagementRemove(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
     Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphId", request.pathParams.auditableItemGraphId);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.documentId", request.pathParams.documentId);
+    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphDocumentId", request.pathParams.auditableItemGraphDocumentId);
+    const revision = Coerce.number(request.pathParams.revision);
+    Guards.integer(ROUTES_SOURCE, "request.pathParams.revision", revision);
     const component = ComponentFactory.get(componentName);
-    await component.remove(request.pathParams.auditableItemGraphId, request.pathParams.documentId, {
-        removeAllRevisions: request.query?.removeAllRevisions
-    }, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    await component.removeRevision(request.pathParams.auditableItemGraphDocumentId, revision, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         statusCode: HttpStatusCode.noContent
     };
@@ -397,14 +574,11 @@ async function documentManagementRemove(httpRequestContext, componentName, reque
  */
 async function documentManagementQuery(httpRequestContext, componentName, request) {
     Guards.object(ROUTES_SOURCE, "request", request);
-    Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    Guards.stringValue(ROUTES_SOURCE, "request.pathParams.auditableItemGraphId", request.pathParams.auditableItemGraphId);
+    Guards.object(ROUTES_SOURCE, "request.query", request.query);
+    Guards.stringValue(ROUTES_SOURCE, "request.query.documentId", request.query.documentId);
     const mimeType = request.headers?.[HeaderTypes.Accept] === MimeTypes.JsonLd ? "jsonld" : "json";
     const component = ComponentFactory.get(componentName);
-    const result = await component.query(request.pathParams.auditableItemGraphId, HttpParameterHelper.arrayFromString(request.query?.documentCodes), {
-        includeRemoved: Coerce.boolean(request.query?.includeRemoved),
-        includeMostRecentRevisions: Coerce.boolean(request.query?.includeMostRecentRevisions)
-    }, request.query?.cursor, httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
+    const result = await component.query(request.query.documentId, request.query?.cursor, Coerce.integer(request.query?.pageSize), httpRequestContext.userIdentity, httpRequestContext.nodeIdentity);
     return {
         headers: {
             [HeaderTypes.ContentType]: mimeType === "json" ? MimeTypes.Json : MimeTypes.JsonLd
@@ -421,11 +595,6 @@ class DocumentManagementService {
      * The namespace supported by the document management service.
      */
     static NAMESPACE = "documents";
-    /**
-     * Default Page Size for cursor.
-     * @internal
-     */
-    static _DEFAULT_PAGE_SIZE = 20;
     /**
      * Runtime name for the class.
      */
@@ -445,6 +614,11 @@ class DocumentManagementService {
      * @internal
      */
     _attestationComponent;
+    /**
+     * The connector for the data processing.
+     * @internal
+     */
+    _dataProcessingComponent;
     /**
      * Create a new instance of DocumentManagementService.
      * @param options The options for the service.
@@ -453,169 +627,218 @@ class DocumentManagementService {
         this._auditableItemGraphComponent = ComponentFactory.get(options?.auditableItemGraphComponentType ?? "auditable-item-graph");
         this._blobStorageComponent = ComponentFactory.get(options?.blobStorageComponentType ?? "blob-storage");
         this._attestationComponent = ComponentFactory.get(options?.attestationComponentType ?? "attestation");
+        this._dataProcessingComponent = ComponentFactory.get(options?.dataProcessingComponentType ?? "data-processing");
         SchemaOrgDataTypes.registerRedirects();
     }
     /**
-     * Store a document in an auditable item graph vertex and add its content to blob storage.
+     * Store a document as an auditable item graph vertex and add its content to blob storage.
      * If the document id already exists and the blob data is different a new revision will be created.
      * For any other changes the current revision will be updated.
-     * @param auditableItemGraphId The auditable item graph vertex id to create the document on.
      * @param documentId The document id to create.
      * @param documentIdFormat The format of the document identifier.
      * @param documentCode The code for the document type.
-     * @param blob The data to create the document.
+     * @param blob The data to create the document with.
      * @param annotationObject Additional information to associate with the document.
+     * @param auditableItemGraphEdges The auditable item graph vertices to connect the document to.
      * @param options Additional options for the set operation.
      * @param options.createAttestation Flag to create an attestation for the document, defaults to false.
-     * @param options.includeIdAsAlias Include the document id as an alias to the aig vertex, defaults to false.
-     * @param options.aliasAnnotationObject Additional information to associate with the alias.
+     * @param options.addAlias Flag to add the document id as an alias to the aig vertex, defaults to true.
+     * @param options.aliasAnnotationObject Annotation object for the alias.
      * @param userIdentity The identity to perform the auditable item graph operation with.
      * @param nodeIdentity The node identity to use for vault operations.
-     * @returns The identifier for the document which includes the auditable item graph identifier.
+     * @returns The auditable item graph vertex created for the document including its revision.
      */
-    async set(auditableItemGraphId, documentId, documentIdFormat, documentCode, blob, annotationObject, options, userIdentity, nodeIdentity) {
-        Guards.stringValue(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
+    async create(documentId, documentIdFormat, documentCode, blob, annotationObject, auditableItemGraphEdges, options, userIdentity, nodeIdentity) {
         Guards.stringValue(this.CLASS_NAME, "documentId", documentId);
         Guards.arrayOneOf(this.CLASS_NAME, "documentCode", documentCode, Object.values(UneceDocumentCodes));
         Guards.uint8Array(this.CLASS_NAME, "blob", blob);
         Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
         Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
         try {
-            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
-            vertex.resources = vertex.resources ?? [];
-            if (options?.includeIdAsAlias ?? false) {
-                vertex.aliases ??= [];
-                const found = vertex.aliases.find(a => a.id === documentId);
-                if (found) {
-                    found.annotationObject = options?.aliasAnnotationObject ?? found.annotationObject;
-                    found.aliasFormat = documentIdFormat ?? found.aliasFormat;
-                }
-                else {
-                    vertex.aliases.push({
-                        "@context": AuditableItemGraphContexts.ContextRoot,
-                        type: AuditableItemGraphTypes.Alias,
-                        id: documentId,
-                        aliasFormat: documentIdFormat,
-                        annotationObject: options?.aliasAnnotationObject
-                    });
+            // Get the connected vertices first, if one fails we abort the create
+            const connectedVertices = {};
+            if (Is.arrayValue(auditableItemGraphEdges)) {
+                for (const edge of auditableItemGraphEdges) {
+                    connectedVertices[edge.id] = await this._auditableItemGraphComponent.get(edge.id);
                 }
             }
-            // Get all the docs from the AIG vertex
-            const vertexDocs = this.filterDocumentsFromVertex(vertex);
-            // Reduce the list to those with a matching id and code
-            const matchingDocIds = this.findMatchingDocs(vertexDocs, documentId, documentCode, true);
-            const currentRevision = matchingDocIds[0];
-            let createAttestation = options?.createAttestation ?? false;
-            // If the create attestation flag is not defined we check to see if any previous
-            // revisions have an attestation and if so we create one for the new revision.
-            if (Is.undefined(options?.createAttestation)) {
-                createAttestation = matchingDocIds.some(d => Is.stringValue(d.attestationId));
-            }
-            // Calculate the hash for the blob.
-            const blobHash = this.generateBlobHash(blob);
-            // Is the blob data the same as the current revision ?
-            if (currentRevision?.blobHash === blobHash) {
-                // Blob data matches so no need to create a new revision
-                // We update the current object if the annotation or createAttestation flag has changed.
-                let updated = false;
-                if (!ObjectHelper.equal(currentRevision.annotationObject, annotationObject, false)) {
-                    currentRevision.annotationObject = annotationObject;
-                    updated = true;
-                }
-                if (createAttestation && Is.empty(currentRevision.attestationId)) {
-                    currentRevision.attestationId = await this.createAttestation(currentRevision, userIdentity, nodeIdentity);
-                    updated = true;
-                }
-                if (updated) {
-                    currentRevision.dateModified = new Date(Date.now()).toISOString();
-                    await this._auditableItemGraphComponent.update(vertex, userIdentity, nodeIdentity);
-                }
-                return currentRevision.id;
+            const documentVertex = {};
+            if (options?.addAlias ?? true) {
+                documentVertex.aliases ??= [];
+                documentVertex.aliases.push({
+                    "@context": AuditableItemGraphContexts.ContextRoot,
+                    type: AuditableItemGraphTypes.Alias,
+                    id: documentId,
+                    aliasFormat: documentIdFormat,
+                    annotationObject: options?.aliasAnnotationObject
+                });
             }
-            // Nothing matches the current blob hash so upload it to blob storage
+            // Add the blob to blob storage
             const blobStorageId = await this._blobStorageComponent.create(Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
-            const documentRevision = matchingDocIds.length;
-            // We are creating a new document, if there is already docs with the same id and code we use the list length
-            // to determine the next revision number.
-            const document = {
+            const currentRevision = {
                 "@context": [
                     DocumentContexts.ContextRoot,
                     DocumentContexts.ContextRootCommon,
                     SchemaOrgContexts.ContextRoot
                 ],
                 type: DocumentTypes.Document,
-                id: this.createIdentifier(documentCode, documentId, documentRevision),
+                id: this.createDocumentId(documentId, 0),
                 documentId,
                 documentIdFormat,
                 documentCode,
-                documentRevision,
-                blobStorageId,
-                blobHash,
+                documentRevision: 0,
                 annotationObject,
+                blobHash: this.generateBlobHash(blob),
+                blobStorageId,
                 dateCreated: new Date(Date.now()).toISOString(),
                 nodeIdentity,
                 userIdentity
             };
-            // If the attestation flag is set then create it
-            if (createAttestation ?? false) {
-                document.attestationId = await this.createAttestation(document, userIdentity, nodeIdentity);
+            if (options?.createAttestation ?? false) {
+                currentRevision.attestationId = await this.createAttestation(currentRevision, userIdentity, nodeIdentity);
             }
-            // Add the new revision in to the AIG
-            vertex.resources.push({
+            // Add the new revision in to the vertex
+            documentVertex.resources ??= [];
+            documentVertex.resources.push({
                 "@context": AuditableItemGraphContexts.ContextRoot,
                 type: AuditableItemGraphTypes.Resource,
-                resourceObject: document
+                resourceObject: currentRevision
             });
-            await this._auditableItemGraphComponent.update(vertex, userIdentity, nodeIdentity);
-            return document.id;
+            // Add the edges from the document to the items
+            this.updateEdges(documentVertex, auditableItemGraphEdges);
+            // And create the vertex
+            const vertexId = await this._auditableItemGraphComponent.create(documentVertex, userIdentity, nodeIdentity);
+            // Now add the edges to the connected vertices
+            await this.updateConnectedEdges(connectedVertices, vertexId, [], auditableItemGraphEdges, documentId, documentIdFormat, userIdentity, nodeIdentity);
+            return vertexId;
         }
         catch (error) {
             if (BaseError.someErrorName(error, "NotFoundError")) {
                 throw error;
             }
-            throw new GeneralError(this.CLASS_NAME, "setFailed", undefined, error);
+            throw new GeneralError(this.CLASS_NAME, "createFailed", undefined, error);
         }
     }
     /**
-     * Get a specific document from an auditable item graph vertex.
-     * @param auditableItemGraphId The auditable item graph vertex id to get the document from.
-     * @param identifier The identifier of the document to get.
+     * Update a document as an auditable item graph vertex and add its content to blob storage.
+     * If the blob data is different a new revision will be created.
+     * For any other changes the current revision will be updated.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
+     * @param blob The data to update the document with.
+     * @param annotationObject Additional information to associate with the document.
+     * @param auditableItemGraphEdges The auditable item graph vertices to connect the document to, if undefined retains current connections.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns Nothing.
+     */
+    async update(auditableItemGraphDocumentId, blob, annotationObject, auditableItemGraphEdges, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
+        Guards.stringValue(this.CLASS_NAME, "userIdentity", userIdentity);
+        Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
+        try {
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId, { includeDeleted: true });
+            if (Is.empty(documentVertex.resources)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
+            }
+            const documents = await this.getDocumentsFromVertex(documentVertex);
+            const latestRevision = documents.itemListElement[0];
+            documentVertex.resources = documentVertex.resources.filter(r => Is.empty(r.dateDeleted));
+            if (Is.empty(latestRevision)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
+            }
+            // If auditableItemGraphEdges is undefined we are not updating the edges
+            // an empty array can be passed to remove all edges
+            const connectedVertices = {};
+            if (Is.array(auditableItemGraphEdges)) {
+                // Get the updated connected vertices first, if one fails we abort the update
+                for (const edge of auditableItemGraphEdges) {
+                    connectedVertices[edge.id] = await this._auditableItemGraphComponent.get(edge.id);
+                }
+                // Also get the current edges in case some need disconnecting
+                if (Is.arrayValue(documents.edges)) {
+                    for (const edgeId of documents.edges) {
+                        // If we haven't retrieved the edge then it must be one that needs removing
+                        if (Is.empty(connectedVertices[edgeId])) {
+                            connectedVertices[edgeId] = await this._auditableItemGraphComponent.get(edgeId);
+                        }
+                    }
+                }
+            }
+            let updatedVertex = false;
+            // If the blob is set and its hash has changed then we create a new revision
+            if (Is.uint8Array(blob)) {
+                const newBlobHash = this.generateBlobHash(blob);
+                if (latestRevision.blobHash !== newBlobHash) {
+                    // Add the blob to blob storage
+                    const blobStorageId = await this._blobStorageComponent.create(Converter.bytesToBase64(blob), undefined, undefined, undefined, undefined, userIdentity, nodeIdentity);
+                    const newRevision = ObjectHelper.clone(latestRevision);
+                    newRevision.documentRevision++;
+                    newRevision.id = this.createDocumentId(newRevision.documentId, newRevision.documentRevision);
+                    newRevision.blobHash = newBlobHash;
+                    newRevision.blobStorageId = blobStorageId;
+                    newRevision.annotationObject = annotationObject;
+                    if (Is.stringValue(latestRevision.attestationId)) {
+                        newRevision.attestationId = await this.createAttestation(newRevision, userIdentity, nodeIdentity);
+                    }
+                    documentVertex.resources.push({
+                        "@context": AuditableItemGraphContexts.ContextRoot,
+                        type: AuditableItemGraphTypes.Resource,
+                        resourceObject: newRevision
+                    });
+                    updatedVertex = true;
+                }
+            }
+            // If the blob wasn't updated but the annotation object has then update the current revision
+            // instead of creating a new one
+            if (!updatedVertex &&
+                !ObjectHelper.equal(latestRevision.annotationObject, annotationObject)) {
+                updatedVertex = true;
+                latestRevision.annotationObject = annotationObject;
+                latestRevision.dateModified = new Date(Date.now()).toISOString();
+            }
+            const existingEdgeIds = documentVertex.edges?.map(e => e.id) ?? [];
+            // Update the edges from the document to the items
+            const edgesUpdated = this.updateEdges(documentVertex, auditableItemGraphEdges);
+            if (edgesUpdated) {
+                updatedVertex = true;
+            }
+            if (updatedVertex) {
+                await this._auditableItemGraphComponent.update(documentVertex, userIdentity, nodeIdentity);
+            }
+            if (edgesUpdated) {
+                await this.updateConnectedEdges(connectedVertices, auditableItemGraphDocumentId, existingEdgeIds, auditableItemGraphEdges, latestRevision.documentId, latestRevision.documentIdFormat, userIdentity, nodeIdentity);
+            }
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "updateFailed", undefined, error);
+        }
+    }
+    /**
+     * Get a document using it's auditable item graph vertex id and optional revision.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
      * @param options Additional options for the get operation.
      * @param options.includeBlobStorageMetadata Flag to include the blob storage metadata for the document, defaults to false.
      * @param options.includeBlobStorageData Flag to include the blob storage data for the document, defaults to false.
      * @param options.includeAttestation Flag to include the attestation information for the document, defaults to false.
      * @param options.includeRemoved Flag to include deleted documents, defaults to false.
-     * @param options.maxRevisionCount Max number of revisions to return, defaults to 0.
-     * @param revisionCursor The cursor to get the next chunk of revisions.
+     * @param options.extractRuleGroupId If provided will extract data from the document using the specified rule group id.
+     * @param options.extractMimeType By default extraction will auto detect the mime type of the document, this can be used to override the detection.
+     * @param cursor The cursor to get the next chunk of revisions.
+     * @param pageSize Page size of items to return, defaults to 1 so only most recent is returned.
      * @param userIdentity The identity to perform the auditable item graph operation with.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns The documents and revisions if requested, ordered by revision descending, cursor is set if there are more document revisions.
      */
-    async get(auditableItemGraphId, identifier, options, revisionCursor, userIdentity, nodeIdentity) {
-        Urn.guard(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
-        Urn.guard(this.CLASS_NAME, "identifier", identifier);
+    async get(auditableItemGraphDocumentId, options, cursor, pageSize, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
         try {
-            const includeBlobStorageMetadata = options?.includeBlobStorageMetadata ?? false;
-            const includeBlobStorageData = options?.includeBlobStorageData ?? false;
-            const includeAttestation = options?.includeAttestation ?? false;
-            const includeRemoved = options?.includeRemoved ?? false;
-            const revCursor = Math.max(Coerce.integer(revisionCursor) ?? 0, 0);
-            const maxRevisionCount = Math.max(Coerce.integer(options?.maxRevisionCount) ?? 0);
-            const documentIdParts = this.parseDocumentId(identifier);
-            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
-            // Get all the docs from the AIG vertex
-            const vertexDocs = this.filterDocumentsFromVertex(vertex);
-            // Reduce the list to those with a matching id and code
-            const matchingDocIds = this.findMatchingDocs(vertexDocs, documentIdParts.documentId, documentIdParts.documentCode, includeRemoved);
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId, { includeDeleted: options?.includeRemoved });
             // Populate the document and revisions with the options set
-            const document = await this.getDocumentAndRevisions(matchingDocIds, identifier, {
-                includeBlobStorageMetadata,
-                includeBlobStorageData,
-                includeAttestation,
-                includeRemoved,
-                maxRevisionCount
-            }, revCursor, userIdentity, nodeIdentity);
-            return JsonLdProcessor.compact(document, document["@context"]);
+            const documents = await this.getDocumentsFromVertex(documentVertex, options, cursor, pageSize, userIdentity, nodeIdentity);
+            return JsonLdProcessor.compact(documents, documents["@context"]);
         }
         catch (error) {
             if (BaseError.someErrorName(error, "NotFoundError")) {
@@ -625,218 +848,237 @@ class DocumentManagementService {
         }
     }
     /**
-     * Remove a specific document from an auditable item graph vertex.
-     * The documents dateDeleted will be set, but can still be queried with the includeRemoved flag.
-     * @param auditableItemGraphId The auditable item graph vertex id to remove the document from.
-     * @param identifier The identifier of the document to remove.
-     * @param options Additional options for the remove operation.
-     * @param options.removeAllRevisions Flag to remove all revisions of the document, defaults to false.
+     * Get a document revision using it's auditable item graph vertex id.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
+     * @param revision The revision id for the document.
+     * @param options Additional options for the get operation.
+     * @param options.includeBlobStorageMetadata Flag to include the blob storage metadata for the document, defaults to false.
+     * @param options.includeBlobStorageData Flag to include the blob storage data for the document, defaults to false.
+     * @param options.includeAttestation Flag to include the attestation information for the document, defaults to false.
+     * @param options.extractRuleGroupId If provided will extract data from the document using the specified rule group id.
+     * @param options.extractMimeType By default extraction will auto detect the mime type of the document, this can be used to override the detection.
      * @param userIdentity The identity to perform the auditable item graph operation with.
      * @param nodeIdentity The node identity to use for vault operations.
-     * @returns Nothing.
+     * @returns The documents and revisions if requested, ordered by revision descending, cursor is set if there are more document revisions.
      */
-    async remove(auditableItemGraphId, identifier, options, userIdentity, nodeIdentity) {
-        Urn.guard(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
-        Urn.guard(this.CLASS_NAME, "identifier", identifier);
+    async getRevision(auditableItemGraphDocumentId, revision, options, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
+        Guards.integer(this.CLASS_NAME, "revision", revision);
         try {
-            const documentIdParts = this.parseDocumentId(identifier);
-            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
-            // Get all the docs from the AIG vertex
-            const vertexDocs = this.filterDocumentsFromVertex(vertex);
-            // Reduce the list to those with a matching id and code
-            const matchingDocIds = this.findMatchingDocs(vertexDocs, documentIdParts.documentId, documentIdParts.documentCode, false);
-            const removeAllRevisions = options?.removeAllRevisions ?? false;
-            const now = Date.now();
-            if (removeAllRevisions) {
-                for (const doc of matchingDocIds) {
-                    doc.dateDeleted = new Date(now).toISOString();
-                }
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId, { includeDeleted: true });
+            if (Is.empty(documentVertex.resources)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
             }
-            else {
-                const matchingRevision = matchingDocIds.find(d => d.documentRevision === documentIdParts.documentRevision);
-                if (matchingRevision) {
-                    matchingRevision.dateDeleted = new Date(now).toISOString();
-                }
-                else {
-                    throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", identifier);
-                }
+            documentVertex.resources = documentVertex.resources.filter(d => d.resourceObject?.documentRevision === revision);
+            if (documentVertex.resources.length === 0) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", revision.toString());
             }
-            await this._auditableItemGraphComponent.update(vertex, userIdentity, nodeIdentity);
+            // Populate the document and revisions with the options set
+            const docList = await this.getDocumentsFromVertex(documentVertex, options, undefined, undefined, userIdentity, nodeIdentity);
+            return JsonLdProcessor.compact(docList.itemListElement[0], docList.itemListElement[0]["@context"]);
         }
         catch (error) {
             if (BaseError.someErrorName(error, "NotFoundError")) {
                 throw error;
             }
-            throw new GeneralError(this.CLASS_NAME, "removeFailed", undefined, error);
+            throw new GeneralError(this.CLASS_NAME, "getRevisionFailed", undefined, error);
         }
     }
     /**
-     * Query an auditable item graph vertex for documents.
-     * @param auditableItemGraphId The auditable item graph vertex to get the documents from.
-     * @param documentCodes The document codes to query for, if undefined gets all document codes.
-     * @param options Additional options for the query operation.
-     * @param options.includeMostRecentRevisions Include the most recent 5 revisions, use the individual get to retrieve more.
-     * @param options.includeRemoved Flag to include deleted documents, defaults to false.
-     * @param cursor The cursor to get the next chunk of documents.
+     * Remove an auditable item graph vertex using it's id.
+     * The document dateDeleted will be set, but can still be queried with the includeRemoved flag.
+     * @param auditableItemGraphDocumentId The auditable item graph vertex id which contains the document.
+     * @param revision The revision of the document to remove.
      * @param userIdentity The identity to perform the auditable item graph operation with.
      * @param nodeIdentity The node identity to use for vault operations.
-     * @returns The most recent revisions of each document, cursor is set if there are more documents.
+     * @returns Nothing.
      */
-    async query(auditableItemGraphId, documentCodes, options, cursor, userIdentity, nodeIdentity) {
-        Urn.guard(this.CLASS_NAME, "auditableItemGraphId", auditableItemGraphId);
+    async removeRevision(auditableItemGraphDocumentId, revision, userIdentity, nodeIdentity) {
+        Urn.guard(this.CLASS_NAME, "auditableItemGraphDocumentId", auditableItemGraphDocumentId);
+        Guards.number(this.CLASS_NAME, "revision", revision);
         try {
-            const includeRemoved = options?.includeRemoved ?? false;
-            const includeMostRecentRevisions = options?.includeMostRecentRevisions ?? false;
-            const docCursor = Math.max(Coerce.integer(cursor) ?? 0, 0);
-            const vertex = await this._auditableItemGraphComponent.get(auditableItemGraphId);
-            // Get all the docs from the AIG vertex
-            const vertexDocs = this.filterDocumentsFromVertex(vertex);
-            let matchingDocIds = vertexDocs;
-            if (Is.arrayValue(documentCodes)) {
-                matchingDocIds = vertexDocs.filter(d => documentCodes.includes(d.documentCode));
-            }
-            const documentIdGroups = {};
-            let docGroupIds = [];
-            for (const doc of matchingDocIds) {
-                const docId = `${doc.documentId}:${doc.documentCode}`;
-                if (!docGroupIds.includes(docId)) {
-                    docGroupIds.push(docId);
-                }
-                documentIdGroups[docId] ??= [];
-                documentIdGroups[docId].push(doc);
-            }
-            let nextDocCursor;
-            if (docGroupIds.length > docCursor + DocumentManagementService._DEFAULT_PAGE_SIZE) {
-                nextDocCursor = (docCursor + DocumentManagementService._DEFAULT_PAGE_SIZE).toString();
-            }
-            docGroupIds = docGroupIds.slice(docCursor, docCursor + DocumentManagementService._DEFAULT_PAGE_SIZE);
-            const finalDocs = [];
-            for (const docId of docGroupIds) {
-                finalDocs.push(await this.getDocumentAndRevisions(documentIdGroups[docId], docId, {
-                    includeAttestation: false,
-                    includeBlobStorageData: false,
-                    includeBlobStorageMetadata: false,
-                    includeRemoved,
-                    maxRevisionCount: includeMostRecentRevisions ? 5 : 0
-                }, 0, userIdentity, nodeIdentity));
-            }
-            const docList = {
-                "@context": [
-                    DocumentContexts.ContextRoot,
-                    DocumentContexts.ContextRootCommon,
-                    SchemaOrgContexts.ContextRoot
-                ],
-                type: DocumentTypes.DocumentList,
-                documents: finalDocs,
-                cursor: nextDocCursor
-            };
-            return JsonLdProcessor.compact(docList, docList["@context"]);
+            const documentVertex = await this._auditableItemGraphComponent.get(auditableItemGraphDocumentId);
+            if (Is.empty(documentVertex.resources)) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNone");
+            }
+            const docRevisionIndex = documentVertex.resources.findIndex(d => d.resourceObject?.documentRevision === revision);
+            if (docRevisionIndex === -1) {
+                throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", revision.toString());
+            }
+            documentVertex.resources.splice(docRevisionIndex, 1);
+            await this._auditableItemGraphComponent.update(documentVertex, userIdentity, nodeIdentity);
         }
         catch (error) {
             if (BaseError.someErrorName(error, "NotFoundError")) {
                 throw error;
             }
-            throw new GeneralError(this.CLASS_NAME, "queryFailed", undefined, error);
+            throw new GeneralError(this.CLASS_NAME, "removeRevisionFailed", undefined, error);
         }
     }
     /**
-     * Encode the document id.
-     * @param documentId The document identifier.
-     * @returns The encoded identifier.
-     * @internal
-     */
-    encodeDocumentIdentifier(documentId, documentRevision) {
-        return `${documentId}:rev-${documentRevision}`;
-    }
-    /**
-     * Decode the document id.
-     * @param documentId The document identifier.
-     * @returns The decoded identifier.
-     * @internal
+     * Find all the document with a specific id.
+     * @param documentId The document id to find in the graph.
+     * @param cursor The cursor to get the next chunk of documents.
+     * @param pageSize The page size to get the next chunk of documents.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
+     * @returns The graph vertices that contain documents referencing the specified document id.
      */
-    decodeDocumentIdentifier(documentId) {
-        const parts = documentId.split(":");
-        const lastPart = parts[parts.length - 1];
-        let revision;
-        if (lastPart.startsWith("rev-")) {
-            revision = Number.parseInt(lastPart.slice(4), 10);
-            parts.pop();
+    async query(documentId, cursor, pageSize, userIdentity, nodeIdentity) {
+        Guards.stringValue(this.CLASS_NAME, "documentId", documentId);
+        try {
+            return this._auditableItemGraphComponent.query({
+                id: documentId,
+                idMode: "both",
+                resourceTypes: [DocumentTypes.Document]
+            }, undefined, undefined, undefined, ["id", "dateCreated", "dateModified", "aliases", "annotationObject", "resources", "edges"], cursor, pageSize);
+        }
+        catch (error) {
+            if (BaseError.someErrorName(error, "NotFoundError")) {
+                throw error;
+            }
+            throw new GeneralError(this.CLASS_NAME, "queryFailed", undefined, error);
         }
-        return { documentId: parts.join(":"), documentRevision: revision };
-    }
-    /**
-     * Create a full identifier for a document.
-     * @param documentCode The document code.
-     * @param documentId The document identifier.
-     * @param documentRevision The document revision.
-     * @returns The full identifier.
-     * @internal
-     */
-    createIdentifier(documentCode, documentId, documentRevision) {
-        const docCode = this.parseDocumentCode(documentCode);
-        return `documents:${docCode}:${this.encodeDocumentIdentifier(documentId, documentRevision)}`;
     }
     /**
-     * Parse the document identifier from the full identifier.
-     * @param identifier The full identifier to parse.
-     * @returns The document identifier.
+     * Update the edges of the document vertex.
+     * @param documentVertex The document vertex to update.
+     * @param auditableItemGraphEdges The list of edges to use.
+     * @returns True if the edges were updated.
      * @internal
      */
-    parseDocumentId(identifier) {
-        const urn = Urn.fromValidString(identifier);
-        const remainingParts = urn.namespaceSpecificParts();
-        if (remainingParts.length < 2) {
-            throw new GeneralError(this.CLASS_NAME, "invalidDocumentId", { identifier });
+    updateEdges(documentVertex, auditableItemGraphEdges) {
+        let changed = false;
+        const existingEdgeIds = documentVertex.edges?.map(e => e.id) ?? [];
+        if (Is.array(auditableItemGraphEdges)) {
+            for (const aigEdge of auditableItemGraphEdges) {
+                const existingIndex = existingEdgeIds.indexOf(aigEdge.id);
+                if (existingIndex !== -1) {
+                    // If the edge already exists then we don't need to add it again
+                    // We just need to remove it from the list of existing ids
+                    // any remaining after this loop will be need to be removed
+                    existingEdgeIds.splice(existingIndex, 1);
+                }
+                else {
+                    const vertexEdge = {
+                        "@context": AuditableItemGraphContexts.ContextRoot,
+                        type: AuditableItemGraphTypes.Edge,
+                        id: aigEdge.id,
+                        edgeRelationships: ["document"]
+                    };
+                    documentVertex.edges ??= [];
+                    documentVertex.edges?.push(vertexEdge);
+                    changed = true;
+                }
+            }
+            // Anything left in the existingEdgeIds array means they need to be removed
+            if (existingEdgeIds.length > 0 && Is.array(documentVertex.edges)) {
+                for (const existingEdgeId of existingEdgeIds) {
+                    const existingIndex = documentVertex.edges.findIndex(e => e.id === existingEdgeId);
+                    if (existingIndex !== -1) {
+                        documentVertex.edges.splice(existingIndex, 1);
+                        changed = true;
+                    }
+                }
+            }
         }
-        const documentCode = `unece:DocumentCodeList#${remainingParts[0]}`;
-        const { documentId, documentRevision } = this.decodeDocumentIdentifier(urn.namespaceSpecific(1));
-        return { documentCode, documentId, documentRevision };
+        return changed;
     }
     /**
-     * Parse the document code from the full identifier.
-     * @param documentCode The document code to parse.
-     * @returns The document code.
+     * Update the edges.
+     * @param connectedVertices The connected vertices for the edges.
+     * @param auditableItemGraphDocumentId The document id to use.
+     * @param documentVertex The document vertex to update.
+     * @param auditableItemGraphEdges The list of edges to use.
+     * @param documentId The document identifier.
+     * @param documentIdFormat The format of the document identifier.
+     * @param userIdentity The identity to perform the auditable item graph operation with.
+     * @param nodeIdentity The node identity to use for vault operations.
      * @internal
      */
-    parseDocumentCode(documentCode) {
-        // Document codes are in the format unece:DocumentCodeList#1, so we need to split the string to get the code.
-        const documentCodeParts = documentCode.split("#");
-        if (documentCodeParts.length !== 2) {
-            throw new GeneralError(this.CLASS_NAME, "invalidDocumentCode", { documentCode });
+    async updateConnectedEdges(connectedVertices, auditableItemGraphDocumentId, existingEdgeIds, auditableItemGraphEdges, documentId, documentIdFormat, userIdentity, nodeIdentity) {
+        if (Is.array(auditableItemGraphEdges)) {
+            for (const aigEdge of auditableItemGraphEdges) {
+                const connected = connectedVertices[aigEdge.id];
+                if (!Is.empty(connected)) {
+                    let updatedConnected = false;
+                    const existingIndex = existingEdgeIds.indexOf(aigEdge.id);
+                    if (existingIndex !== -1) {
+                        // If the edge already exists we remove it from the list of existing ids
+                        // any remaining after this loop will be need to be disconnected
+                        existingEdgeIds.splice(existingIndex, 1);
+                    }
+                    // Add the edge with the document vertex id if it doesn't already exist
+                    const hasEdge = connected.edges?.some(e => e.id === auditableItemGraphDocumentId);
+                    if (!hasEdge) {
+                        const vertexEdge = {
+                            "@context": AuditableItemGraphContexts.ContextRoot,
+                            type: AuditableItemGraphTypes.Edge,
+                            id: auditableItemGraphDocumentId,
+                            edgeRelationships: ["document"]
+                        };
+                        connected.edges ??= [];
+                        connected.edges?.push(vertexEdge);
+                        updatedConnected = true;
+                    }
+                    // Add alias with the document id if option flag is set and it doesn't already exist
+                    if (aigEdge.addAlias) {
+                        const alias = connected.aliases?.find(a => a.id === documentId);
+                        if (Is.empty(alias)) {
+                            // No existing alias, so create one
+                            const vertexAlias = {
+                                "@context": AuditableItemGraphContexts.ContextRoot,
+                                type: AuditableItemGraphTypes.Alias,
+                                id: documentId,
+                                aliasFormat: documentIdFormat,
+                                annotationObject: aigEdge.aliasAnnotationObject
+                            };
+                            connected.aliases ??= [];
+                            connected.aliases?.push(vertexAlias);
+                            updatedConnected = true;
+                        }
+                        else if (!ObjectHelper.equal(alias.annotationObject, aigEdge.aliasAnnotationObject) ||
+                            documentIdFormat !== alias.aliasFormat) {
+                            // The alias already exists, but the format or annotation object has changed
+                            alias.annotationObject = aigEdge.aliasAnnotationObject;
+                            alias.aliasFormat = documentIdFormat;
+                            updatedConnected = true;
+                        }
+                    }
+                    if (updatedConnected) {
+                        await this._auditableItemGraphComponent.update(connected, userIdentity, nodeIdentity);
+                    }
+                }
+            }
         }
-        const docCode = Number.parseInt(documentCodeParts[1], 10);
-        if (!Is.number(docCode)) {
-            throw new GeneralError(this.CLASS_NAME, "invalidDocumentCode", { documentCode });
+        // Anything left in the existingEdgeIds array means they need to be removed
+        if (existingEdgeIds.length > 0) {
+            for (const existingEdgeId of existingEdgeIds) {
+                const connected = connectedVertices[existingEdgeId];
+                if (!Is.empty(connected)) {
+                    let updatedConnected = false;
+                    // Remove the edge from the connected vertex
+                    if (Is.arrayValue(connected.edges)) {
+                        const existingIndex = connected.edges.findIndex(e => e.id === auditableItemGraphDocumentId);
+                        if (existingIndex !== -1) {
+                            connected.edges.splice(existingIndex, 1);
+                            updatedConnected = true;
+                        }
+                    }
+                    // Remove the alias from the connected vertex
+                    if (Is.arrayValue(connected.aliases)) {
+                        const existingIndex = connected.aliases.findIndex(e => e.id === documentId);
+                        if (existingIndex !== -1) {
+                            connected.aliases.splice(existingIndex, 1);
+                            updatedConnected = true;
+                        }
+                    }
+                    if (updatedConnected) {
+                        await this._auditableItemGraphComponent.update(connected, userIdentity, nodeIdentity);
+                    }
+                }
+            }
         }
-        return docCode;
-    }
-    /**
-     * Get the documents from a vertex.
-     * @param vertex The vertex to get the documents from.
-     * @returns The documents.
-     * @internal
-     */
-    filterDocumentsFromVertex(vertex) {
-        return (vertex.resources
-            ?.filter(resource => ObjectHelper.extractProperty(resource.resourceObject, ["@type", "type"], false) ===
-            DocumentTypes.Document)
-            .map(resource => resource.resourceObject) ?? []);
-    }
-    /**
-     * Find matching documents in the list of existing documents.
-     * @param documents The documents to search.
-     * @param documentId The document id.
-     * @param documentCode The document code.
-     * @param includeRemoved Include deleted documents.
-     * @returns The matching documents.
-     * @internal
-     */
-    findMatchingDocs(documents, documentId, documentCode, includeRemoved) {
-        return documents
-            .filter(d => d.documentId === documentId &&
-            d.documentCode === documentCode &&
-            (includeRemoved || Is.empty(d.dateDeleted)))
-            .sort((a, b) => b.documentRevision - a.documentRevision);
     }
     /**
      * Generate a hash for the blob data.
@@ -849,47 +1091,91 @@ class DocumentManagementService {
     }
     /**
      * Get the documents from the auditable item graph vertex.
-     * @param matchingDocIds The documents which match document type and id.
-     * @param identifier The full document identifier.
+     * @param documentVertex The vertex containing the documents.
      * @param options Additional options for the get operation.
      * @param options.includeBlobStorageMetadata Flag to include the blob storage metadata for the document, defaults to false.
      * @param options.includeBlobStorageData Flag to include the blob storage data for the document, defaults to false.
      * @param options.includeAttestation Flag to include the attestation information for the document, defaults to false.
-     * @param options.includeRemoved Flag to include deleted documents, defaults to false.
-     * @param options.maxRevisionCount Max number of revisions to return, defaults to 0.
-     * @param revisionCursor The cursor to get the next chunk of revisions.
+     * @param options.extractRuleGroupId If provided will extract data from the document using the specified rule group id.
+     * @param options.extractMimeType By default extraction will auto detect the mime type of the document, this can be used to override the detection.
+     * @param cursor The cursor to get the next chunk of revisions.
+     * @param pageSize Page size of items to return, defaults to 1 so only most recent is returned.
      * @param userIdentity The identity to perform the auditable item graph operation with.
      * @param nodeIdentity The node identity to use for vault operations.
      * @returns The finalised list of documents.
      * @internal
      */
-    async getDocumentAndRevisions(matchingDocIds, identifier, options, revisionCursor, userIdentity, nodeIdentity) {
-        const document = matchingDocIds.shift();
-        if (Is.empty(document)) {
-            throw new NotFoundError(this.CLASS_NAME, "documentRevisionNotFound", identifier);
-        }
-        let revisions;
-        let nextRevisionCursor;
-        if (options.maxRevisionCount > 0) {
-            revisions = matchingDocIds.slice(revisionCursor, revisionCursor + options.maxRevisionCount);
-            nextRevisionCursor =
-                matchingDocIds.length > revisionCursor + options.maxRevisionCount
-                    ? (revisionCursor + options.maxRevisionCount).toString()
-                    : undefined;
-        }
-        if (options.includeBlobStorageMetadata || options.includeBlobStorageData) {
-            const blobEntry = await this._blobStorageComponent.get(document.blobStorageId, options.includeBlobStorageData, userIdentity, nodeIdentity);
-            document.blobStorageEntry = blobEntry;
-            document["@context"].push(BlobStorageContexts.ContextRoot);
+    async getDocumentsFromVertex(documentVertex, options, cursor, pageSize, userIdentity, nodeIdentity) {
+        const docList = {
+            "@context": [
+                SchemaOrgContexts.ContextRoot,
+                DocumentContexts.ContextRoot,
+                DocumentContexts.ContextRootCommon
+            ],
+            type: SchemaOrgTypes.ItemList,
+            [SchemaOrgTypes.ItemListElement]: []
+        };
+        if (Is.arrayValue(documentVertex.resources)) {
+            // Sort by newest revision first
+            documentVertex.resources.sort((a, b) => (Coerce.number(b.resourceObject?.documentRevision) ?? 0) -
+                (Coerce.number(a.resourceObject?.documentRevision) ?? 0));
+            const startIndex = Coerce.integer(cursor) ?? 0;
+            const endIndex = Math.min(startIndex + (pageSize ?? 1), documentVertex.resources.length);
+            const slicedResources = documentVertex.resources.slice(startIndex, endIndex);
+            docList[SchemaOrgTypes.NextItem] =
+                documentVertex.resources.length > endIndex ? (endIndex + 1).toString() : undefined;
+            const includeBlobStorageMetadata = options?.includeBlobStorageMetadata ?? false;
+            const includeBlobStorageData = options?.includeBlobStorageData ?? false;
+            const includeAttestation = options?.includeAttestation ?? false;
+            const extractData = Is.stringValue(options?.extractRuleGroupId);
+            for (let i = 0; i < slicedResources.length; i++) {
+                const document = slicedResources[i].resourceObject;
+                if (Is.object(document)) {
+                    document.dateDeleted = slicedResources[i].dateDeleted;
+                    docList[SchemaOrgTypes.ItemListElement].push(document);
+                    const blobRequired = includeBlobStorageMetadata || includeBlobStorageData;
+                    if (blobRequired || extractData) {
+                        const blobEntry = await this._blobStorageComponent.get(document.blobStorageId, {
+                            includeContent: includeBlobStorageData || extractData
+                        }, userIdentity, nodeIdentity);
+                        if (blobRequired) {
+                            document.blobStorageEntry = blobEntry;
+                            if (!docList["@context"].includes(BlobStorageContexts.ContextRoot)) {
+                                docList["@context"].push(BlobStorageContexts.ContextRoot);
+                            }
+                        }
+                        if (Is.stringValue(options?.extractRuleGroupId) && Is.stringValue(blobEntry.blob)) {
+                            const binaryBlob = Converter.base64ToBytes(blobEntry.blob);
+                            document.extractedData = await this._dataProcessingComponent.extract(options.extractRuleGroupId, binaryBlob, undefined, options?.extractMimeType);
+                        }
+                        // If we have the blob data due to extraction but we weren't asked for it
+                        // then we remove it from the document
+                        if (!blobRequired) {
+                            delete document.blobStorageEntry;
+                        }
+                        else if (!includeBlobStorageData) {
+                            delete document.blobStorageEntry?.blob;
+                        }
+                    }
+                    if (includeAttestation && Is.stringValue(document.attestationId)) {
+                        const attestationInformation = await this._attestationComponent.get(document.attestationId);
+                        document.attestationInformation = attestationInformation;
+                        if (!docList["@context"].includes(AttestationContexts.ContextRoot)) {
+                            docList["@context"].push(AttestationContexts.ContextRoot);
+                        }
+                    }
+                }
+            }
         }
-        if (options.includeAttestation && Is.stringValue(document.attestationId)) {
-            const attestationInformation = await this._attestationComponent.get(document.attestationId);
-            document.attestationInformation = attestationInformation;
-            document["@context"].push(AttestationContexts.ContextRoot);
+        if (Is.arrayValue(documentVertex.edges)) {
+            docList.edges ??= [];
+            for (const edge of documentVertex.edges) {
+                if (Is.object(edge)) {
+                    docList.edges.push(edge.id);
+                }
+            }
         }
-        document.revisions = Is.arrayValue(revisions) ? revisions : undefined;
-        document.revisionCursor = nextRevisionCursor;
-        return document;
+        return docList;
     }
     /**
      * Create an attestation for the document.
@@ -906,6 +1192,7 @@ class DocumentManagementService {
                 SchemaOrgContexts.ContextRoot
             ],
             type: DocumentTypes.DocumentAttestation,
+            id: document.id,
             documentId: document.documentId,
             documentCode: document.documentCode,
             documentRevision: document.documentRevision,
@@ -914,15 +1201,26 @@ class DocumentManagementService {
         };
         return this._attestationComponent.create(documentAttestation, undefined, userIdentity, nodeIdentity);
     }
+    /**
+     * Create a document id from the document id and revision.
+     * @param documentId The document id to create.
+     * @param revision The revision of the document.
+     * @returns The document id.
+     * @internal
+     */
+    createDocumentId(documentId, revision) {
+        const documentIdHash = Converter.bytesToBase64Url(Sha256.sum256(Converter.utf8ToBytes(documentId)));
+        return `document:${documentIdHash}:${revision}`;
+    }
 }
 
 const restEntryPoints = [
     {
-        name: "documents",
-        defaultBaseRoute: "documents",
+        name: "document-management",
+        defaultBaseRoute: "document-management",
         tags: tagsDocumentManagement,
         generateRoutes: generateRestRoutesDocumentManagement
     }
 ];
 
-export { DocumentManagementService, documentManagementGet, documentManagementQuery, documentManagementRemove, documentManagementSet, generateRestRoutesDocumentManagement, restEntryPoints, tagsDocumentManagement };
+export { DocumentManagementService, documentManagementCreate, documentManagementGet, documentManagementGetRevision, documentManagementQuery, documentManagementRemove, documentManagementUpdate, generateRestRoutesDocumentManagement, restEntryPoints, tagsDocumentManagement };