@twin.org/rights-management-service 0.0.2-next.4 → 0.0.2-next.6

package/dist/cjs/index.cjs

@@ -10,27 +10,27 @@ var web = require('@twin.org/web');
 /**
  * The source used when communicating about these routes.
  */
-const ROUTES_SOURCE = "rightsManagementRoutes";
+const ROUTES_SOURCE$3 = "policyAdministrationPointRoutes";
 /**
  * The tag to associate with the routes.
  */
-const tags = [
+const papTags = [
     {
         name: "Policy Administration Point",
         description: "Endpoints for managing ODRL policies in the Policy Administration Point"
     }
 ];
 /**
- * The REST routes for the Rights Management.
+ * The REST routes for the Policy Administration Point.
  * @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.
  */
-function generateRestRoutesRightsManagement(baseRouteName, componentName) {
-    const createRoute = {
+function generateRestRoutesPolicyAdministrationPoint(baseRouteName, componentName) {
+    const papCreateRoute = {
         operationId: "papCreate",
         summary: "Create a policy",
-        tag: tags[0].name,
+        tag: papTags[0].name,
         method: "POST",
         path: `${baseRouteName}/pap/`,
         handler: async (httpRequestContext, request) => papCreate(httpRequestContext, componentName, request),
@@ -38,7 +38,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapCreateRequest",
             examples: [
                 {
-                    id: "papCreateExample",
+                    id: "papCreateRequestExample",
                     request: {
                         body: {
                             "@context": standardsW3cOdrl.OdrlContexts.ContextRoot,
@@ -71,10 +71,10 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const updateRoute = {
+    const papUpdateRoute = {
         operationId: "papUpdate",
         summary: "Update a policy",
-        tag: tags[0].name,
+        tag: papTags[0].name,
         method: "PUT",
         path: `${baseRouteName}/pap/:id`,
         handler: async (httpRequestContext, request) => papUpdate(httpRequestContext, componentName, request),
@@ -82,7 +82,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapUpdateRequest",
             examples: [
                 {
-                    id: "papUpdateExample",
+                    id: "papUpdateRequestExample",
                     request: {
                         pathParams: {
                             id: "urn:rights-management:abc123def456"
@@ -108,18 +108,18 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const retrieveRoute = {
-        operationId: "papRetrieve",
-        summary: "Retrieve a policy",
-        tag: tags[0].name,
+    const papGetRoute = {
+        operationId: "papGet",
+        summary: "Get a policy",
+        tag: papTags[0].name,
         method: "GET",
         path: `${baseRouteName}/pap/:id`,
-        handler: async (httpRequestContext, request) => papRetrieve(httpRequestContext, componentName, request),
+        handler: async (httpRequestContext, request) => papGet(httpRequestContext, componentName, request),
         requestType: {
-            type: "IPapRetrieveRequest",
+            type: "IPapGetRequest",
             examples: [
                 {
-                    id: "papRetrieveExample",
+                    id: "papGetRequestExample",
                     request: {
                         pathParams: {
                             id: "urn:rights-management:abc123def456"
@@ -130,10 +130,10 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
         },
         responseType: [
             {
-                type: "IPapRetrieveResponse",
+                type: "IPapGetResponse",
                 examples: [
                     {
-                        id: "papRetrieveResponseExample",
+                        id: "papGetResponseExample",
                         response: {
                             body: {
                                 "@context": standardsW3cOdrl.OdrlContexts.ContextRoot,
@@ -152,10 +152,10 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const removeRoute = {
+    const papRemoveRoute = {
         operationId: "papRemove",
         summary: "Remove a policy",
-        tag: tags[0].name,
+        tag: papTags[0].name,
         method: "DELETE",
         path: `${baseRouteName}/pap/:id`,
         handler: async (httpRequestContext, request) => papRemove(httpRequestContext, componentName, request),
@@ -163,7 +163,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapRemoveRequest",
             examples: [
                 {
-                    id: "papRemoveExample",
+                    id: "papRemoveRequestExample",
                     request: {
                         pathParams: {
                             id: "urn:rights-management:abc123def456"
@@ -178,10 +178,10 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const queryRoute = {
+    const papQueryRoute = {
         operationId: "papQuery",
         summary: "Query policies",
-        tag: tags[0].name,
+        tag: papTags[0].name,
         method: "GET",
         path: `${baseRouteName}/pap/query`,
         handler: async (httpRequestContext, request) => papQuery(httpRequestContext, componentName, request),
@@ -189,7 +189,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapQueryRequest",
             examples: [
                 {
-                    id: "papQueryExample",
+                    id: "papQueryRequestExample",
                     request: {
                         query: {
                             cursor: "optional-pagination-cursor"
@@ -227,10 +227,123 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const interceptRoute = {
+    return [papCreateRoute, papUpdateRoute, papGetRoute, papRemoveRoute, papQueryRoute];
+}
+/**
+ * PAP: Create a policy.
+ * @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 papCreate(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$3, "request", request);
+    core.Guards.object(ROUTES_SOURCE$3, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    const policy = request.body;
+    const uid = await component.create(policy);
+    return {
+        statusCode: web.HttpStatusCode.created,
+        headers: {
+            location: uid
+        }
+    };
+}
+/**
+ * PAP: Update a policy.
+ * @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 papUpdate(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$3, "request", request);
+    core.Guards.object(ROUTES_SOURCE$3, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$3, "request.pathParams.id", request.pathParams.id);
+    core.Guards.object(ROUTES_SOURCE$3, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    await component.update(request.body);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * PAP: Get a policy.
+ * @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 papGet(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$3, "request", request);
+    core.Guards.object(ROUTES_SOURCE$3, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$3, "request.pathParams.id", request.pathParams.id);
+    const component = core.ComponentFactory.get(componentName);
+    const policy = await component.get(request.pathParams.id);
+    return {
+        body: policy
+    };
+}
+/**
+ * PAP: Remove a policy.
+ * @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 papRemove(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$3, "request", request);
+    core.Guards.object(ROUTES_SOURCE$3, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$3, "request.pathParams.id", request.pathParams.id);
+    const component = core.ComponentFactory.get(componentName);
+    await component.remove(request.pathParams.id);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
+}
+/**
+ * PAP: Query policies.
+ * @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 papQuery(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$3, "request", request);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.query(apiModels.HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.cursor, core.Coerce.integer(request.query?.pageSize));
+    return {
+        body: {
+            cursor: result.cursor,
+            policies: result.policies
+        }
+    };
+}
+
+/**
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE$2 = "policyEnforcementPointRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+const pepTags = [
+    {
+        name: "Policy Enforcement Point",
+        description: "Endpoints for managing ODRL policies in the Policy Enforcement Point"
+    }
+];
+/**
+ * The REST routes for the Policy Enforcement Point.
+ * @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.
+ */
+function generateRestRoutesPolicyEnforcementPoint(baseRouteName, componentName) {
+    const pepInterceptRoute = {
         operationId: "pepIntercept",
         summary: "Intercept a request",
-        tag: tags[0].name,
+        tag: pepTags[0].name,
         method: "POST",
         path: `${baseRouteName}/pep/intercept`,
         handler: async (httpRequestContext, request) => pepIntercept(httpRequestContext, componentName, request),
@@ -238,7 +351,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPepInterceptRequest",
             examples: [
                 {
-                    id: "pepInterceptExample",
+                    id: "pepInterceptRequestExample",
                     request: {
                         body: {
                             assetType: "document",
@@ -270,250 +383,457 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    return [createRoute, updateRoute, retrieveRoute, removeRoute, queryRoute, interceptRoute];
+    return [pepInterceptRoute];
 }
 /**
- * PAP: Create a policy.
+ * PEP: Intercept.
  * @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 papCreate(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.nodeIdentity", httpRequestContext.nodeIdentity);
+async function pepIntercept(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$2, "request", request);
     const component = core.ComponentFactory.get(componentName);
-    const policy = request.body;
-    const uid = await component.papCreate(policy);
+    const result = await component.intercept(request.body.assetType, request.body.action, {
+        ...(request.body.context ?? {}),
+        userIdentity: httpRequestContext.userIdentity,
+        nodeIdentity: httpRequestContext.nodeIdentity
+    }, request.body.data);
     return {
-        statusCode: web.HttpStatusCode.created,
-        headers: {
-            location: uid
-        }
+        body: result
     };
 }
+
 /**
- * PAP: Update a policy.
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE$1 = "policyNegotiationAdminPointRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+const pnapTags = [
+    {
+        name: "Policy Negotiation Administration Point",
+        description: "Endpoints for managing ODRL policies in the Policy Negotiation Administration Point"
+    }
+];
+/**
+ * The REST routes for the Policy Negotiation Administration Point.
+ * @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.
+ */
+function generateRestRoutesPolicyNegotiationAdminPoint(baseRouteName, componentName) {
+    const pnapGetRoute = {
+        operationId: "pnapGet",
+        summary: "Get a policy negotiation",
+        tag: pnapTags[0].name,
+        method: web.HttpMethod.GET,
+        path: `${baseRouteName}/pnap/:policyId`,
+        handler: async (httpRequestContext, request) => pnapGet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnapGetRequest",
+            examples: [
+                {
+                    id: "pnapGetRequestExample",
+                    request: {
+                        pathParams: { policyId: "policy-1" }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IPnapGetResponse",
+                examples: [
+                    {
+                        id: "pnapGetResponseExample",
+                        response: {
+                            body: {
+                                id: "policy-1",
+                                status: "manual",
+                                dateCreated: "2025-09-03T00:00:00.000Z",
+                                assetType: "document",
+                                action: "view",
+                                context: {}
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    const pnapSetRoute = {
+        operationId: "pnapSet",
+        summary: "Set a policy negotiation",
+        tag: pnapTags[0].name,
+        method: web.HttpMethod.PUT,
+        path: `${baseRouteName}/pnap/:policyId`,
+        handler: async (httpRequestContext, request) => pnapSet(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnapSetRequest",
+            examples: [
+                {
+                    id: "pnapSetRequestExample",
+                    request: {
+                        pathParams: { policyId: "policy-1" },
+                        body: {
+                            id: "policy-1",
+                            status: "approved",
+                            dateCreated: "2025-09-03T00:00:00.000Z",
+                            assetType: "document",
+                            action: "view",
+                            context: {}
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [{ type: "INoContentResponse" }]
+    };
+    const pnapRemoveRoute = {
+        operationId: "pnapRemove",
+        summary: "Remove a policy negotiation",
+        tag: pnapTags[0].name,
+        method: web.HttpMethod.DELETE,
+        path: `${baseRouteName}/pnap/:policyId`,
+        handler: async (httpRequestContext, request) => pnapRemove(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnapRemoveRequest",
+            examples: [
+                {
+                    id: "pnapRemoveRequestExample",
+                    request: {
+                        pathParams: { policyId: "policy-1" }
+                    }
+                }
+            ]
+        },
+        responseType: [{ type: "INoContentResponse" }]
+    };
+    const pnapQueryRoute = {
+        operationId: "pnapQuery",
+        summary: "Query policy negotiations",
+        tag: pnapTags[0].name,
+        method: web.HttpMethod.GET,
+        path: `${baseRouteName}/pnap`,
+        handler: async (httpRequestContext, request) => pnapQuery(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnapQueryRequest",
+            examples: [
+                {
+                    id: "pnapQueryRequestExample",
+                    request: {
+                        query: { status: "manual", cursor: "next-cursor" }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IPnapQueryResponse",
+                examples: [
+                    {
+                        id: "pnapQueryResponseExample",
+                        response: {
+                            body: {
+                                items: [
+                                    {
+                                        id: "policy-1",
+                                        status: "manual",
+                                        dateCreated: "2025-09-03T00:00:00.000Z",
+                                        assetType: "document",
+                                        action: "view",
+                                        context: {}
+                                    }
+                                ],
+                                cursor: "next-cursor"
+                            }
+                        }
+                    }
+                ]
+            }
+        ]
+    };
+    return [pnapGetRoute, pnapSetRoute, pnapRemoveRoute, pnapQueryRoute];
+}
+/**
+ * PNAP: Get a policy negotiation.
  * @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 papUpdate(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.nodeIdentity", httpRequestContext.nodeIdentity);
+async function pnapGet(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$1, "request", request);
+    core.Guards.object(ROUTES_SOURCE$1, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$1, "request.pathParams.policyId", request.pathParams.policyId);
     const component = core.ComponentFactory.get(componentName);
-    await component.papUpdate(request.body);
+    const negotiation = await component.get(request.pathParams.policyId);
     return {
-        statusCode: web.HttpStatusCode.noContent
+        body: negotiation
     };
 }
 /**
- * PAP: Retrieve a policy.
+ * PNAP: Set a policy negotiation.
  * @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 papRetrieve(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
-    core.Guards.stringValue(ROUTES_SOURCE, "httpRequestContext.nodeIdentity", httpRequestContext.nodeIdentity);
+async function pnapSet(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$1, "request", request);
+    core.Guards.object(ROUTES_SOURCE$1, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$1, "request.pathParams.policyId", request.pathParams.policyId);
+    core.Guards.object(ROUTES_SOURCE$1, "request.body", request.body);
     const component = core.ComponentFactory.get(componentName);
-    const policy = await component.papRetrieve(request.pathParams.id);
+    await component.set(request.body);
     return {
-        body: policy
+        statusCode: web.HttpStatusCode.noContent
     };
 }
 /**
- * PAP: Remove a policy.
+ * PNAP: Remove a policy negotiation.
  * @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 papRemove(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.pathParams", request.pathParams);
-    core.Guards.stringValue(ROUTES_SOURCE, "request.pathParams.id", request.pathParams.id);
+async function pnapRemove(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$1, "request", request);
+    core.Guards.object(ROUTES_SOURCE$1, "request.pathParams", request.pathParams);
+    core.Guards.stringValue(ROUTES_SOURCE$1, "request.pathParams.policyId", request.pathParams.policyId);
     const component = core.ComponentFactory.get(componentName);
-    await component.papRemove(request.pathParams.id);
+    await component.remove(request.pathParams.policyId);
     return {
         statusCode: web.HttpStatusCode.noContent
     };
 }
 /**
- * PAP: Query policies.
+ * PNAP: Query policy negotiations.
  * @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 papQuery(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
+async function pnapQuery(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$1, "request", request);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.papQuery(apiModels.HttpParameterHelper.objectFromString(request.query?.conditions), request.query?.cursor, core.Coerce.integer(request.query?.pageSize));
+    const result = await component.query(request.query?.status, request.query?.cursor);
     return {
         body: {
-            cursor: result.cursor,
-            policies: result.policies
+            items: result.items,
+            cursor: result.cursor
         }
     };
 }
+
 /**
- * PEP: Intercept.
+ * The source used when communicating about these routes.
+ */
+const ROUTES_SOURCE = "policyNegotiationPointRoutes";
+/**
+ * The tag to associate with the routes.
+ */
+const pnpTags = [
+    {
+        name: "Policy Negotiation Point",
+        description: "Endpoints for managing ODRL policies in the Policy Negotiation Point"
+    }
+];
+/**
+ * The REST routes for the Policy Negotiation Point.
+ * @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.
+ */
+function generateRestRoutesPolicyNegotiationPoint(baseRouteName, componentName) {
+    const pnpNegotiateRoute = {
+        operationId: "pnpNegotiate",
+        summary: "Negotiate a policy",
+        tag: pnpTags[0].name,
+        method: "POST",
+        path: `${baseRouteName}/pnp/negotiate`,
+        handler: async (httpRequestContext, request) => pnpNegotiate(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnpNegotiateRequest",
+            examples: [
+                {
+                    id: "pnpNegotiateRequestExample",
+                    request: {
+                        body: {
+                            assetType: "document",
+                            action: "view",
+                            context: {
+                                nodeIdentity: "urn:example:node:1"
+                            },
+                            proof: {
+                                created: "2024-08-22T11:56:56.272Z",
+                                type: "DataIntegrityProof",
+                                cryptosuite: "eddsa-jcs-2022",
+                                proofPurpose: "assertionMethod",
+                                proofValue: "z3Vcuh2BP9ShC4UEJ3yRZgcTJ6gmRtydDrh6AmY1zEciQqEWTvXfBZNxxjTzdJjT44cmn9VDWbBHqxFsX9fjsfXzK",
+                                verificationMethod: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363#assertion"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IPnpNegotiateResponse",
+                examples: [
+                    {
+                        id: "IPnpNegotiateResponseExample",
+                        response: {
+                            body: {
+                                id: "policy-1",
+                                status: "approved"
+                            }
+                        }
+                    }
+                ]
+            }
+        ],
+        skipAuth: true
+    };
+    const papNegotiationStateRoute = {
+        operationId: "pnpNegotiationState",
+        summary: "Get the state of a policy",
+        tag: pnpTags[0].name,
+        method: "POST",
+        path: `${baseRouteName}/pnp/:policyId`,
+        handler: async (httpRequestContext, request) => pnpNegotiationState(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnpNegotiationStateRequest",
+            examples: [
+                {
+                    id: "pnpNegotiationStateRequestExample",
+                    request: {
+                        pathParams: {
+                            policyId: "policy-1"
+                        },
+                        body: {
+                            nodeIdentity: "urn:example:node:1",
+                            proof: {
+                                created: "2024-08-22T11:56:56.272Z",
+                                type: "DataIntegrityProof",
+                                cryptosuite: "eddsa-jcs-2022",
+                                proofPurpose: "assertionMethod",
+                                proofValue: "z3Vcuh2BP9ShC4UEJ3yRZgcTJ6gmRtydDrh6AmY1zEciQqEWTvXfBZNxxjTzdJjT44cmn9VDWbBHqxFsX9fjsfXzK",
+                                verificationMethod: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363#assertion"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "IPnpNegotiationStateResponse",
+                examples: [
+                    {
+                        id: "IPnpNegotiationStateResponseExample",
+                        response: {
+                            body: {
+                                id: "policy-1",
+                                status: "approved"
+                            }
+                        }
+                    }
+                ]
+            }
+        ],
+        skipAuth: true
+    };
+    const pnpNegotiationCancelRoute = {
+        operationId: "pnpCancel",
+        summary: "Cancel a policy negotiation",
+        tag: pnpTags[0].name,
+        method: "DELETE",
+        path: `${baseRouteName}/pnp/:policyId`,
+        handler: async (httpRequestContext, request) => pnpNegotiationCancel(httpRequestContext, componentName, request),
+        requestType: {
+            type: "IPnpNegotiationCancelRequest",
+            examples: [
+                {
+                    id: "pnpNegotiationCancelRequestExample",
+                    request: {
+                        pathParams: {
+                            policyId: "policy-1"
+                        },
+                        body: {
+                            nodeIdentity: "urn:example:node:1",
+                            proof: {
+                                created: "2024-08-22T11:56:56.272Z",
+                                type: "DataIntegrityProof",
+                                cryptosuite: "eddsa-jcs-2022",
+                                proofPurpose: "assertionMethod",
+                                proofValue: "z3Vcuh2BP9ShC4UEJ3yRZgcTJ6gmRtydDrh6AmY1zEciQqEWTvXfBZNxxjTzdJjT44cmn9VDWbBHqxFsX9fjsfXzK",
+                                verificationMethod: "did:entity-storage:0x6363636363636363636363636363636363636363636363636363636363636363#assertion"
+                            }
+                        }
+                    }
+                }
+            ]
+        },
+        responseType: [
+            {
+                type: "INoContentResponse"
+            }
+        ],
+        skipAuth: true
+    };
+    return [pnpNegotiateRoute, papNegotiationStateRoute, pnpNegotiationCancelRoute];
+}
+/**
+ * PNP: Negotiate.
  * @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 pepIntercept(httpRequestContext, componentName, request) {
+async function pnpNegotiate(httpRequestContext, componentName, request) {
     core.Guards.object(ROUTES_SOURCE, "request", request);
     const component = core.ComponentFactory.get(componentName);
-    const result = await component.pepIntercept(request.body.assetType, request.body.action, request.body.data, httpRequestContext.userIdentity ?? "", httpRequestContext.nodeIdentity ?? "");
+    const result = await component.negotiate(request.body.assetType, request.body.action, request.body.resourceId, request.body.context, request.body.requesterInformation, request.body.proof);
     return {
         body: result
     };
 }
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
 /**
- * Service for performing Rights Management operations.
- * This is a unified service that provides access to all Rights Management components.
+ * PNP: Negotiation State.
+ * @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.
  */
-class RightsManagementService {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "RightsManagementService";
-    /**
-     * The PAP component implementation.
-     * @internal
-     */
-    _policyAdministrationPointComponent;
-    /**
-     * The PEP component implementation.
-     * @internal
-     */
-    _policyEnforcementPointComponent;
-    /**
-     * Create a new instance of RightsManagementService.
-     * @param options The options for the service.
-     */
-    constructor(options) {
-        this._policyAdministrationPointComponent =
-            core.ComponentFactory.get(options?.policyAdministrationPointComponentType ?? "policy-administration-point");
-        this._policyEnforcementPointComponent = core.ComponentFactory.get(options?.policyEnforcementPointComponentType ?? "policy-enforcement-point");
-    }
-    /**
-     * PAP: Create a new policy with auto-generated UID.
-     * @param policy The policy to create (uid will be auto-generated).
-     * @returns The UID of the created policy.
-     */
-    async papCreate(policy) {
-        core.Guards.object(this.CLASS_NAME, "policy", policy);
-        try {
-            const result = await this._policyAdministrationPointComponent.create(policy);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "papCreateFailed", undefined, error);
-        }
-    }
-    /**
-     * PAP: Update an existing policy.
-     * @param policy The policy to update (must include uid).
-     * @returns Nothing.
-     */
-    async papUpdate(policy) {
-        core.Guards.object(this.CLASS_NAME, "policy", policy);
-        try {
-            await this._policyAdministrationPointComponent.update(policy);
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "papUpdateFailed", undefined, error);
-        }
-    }
-    /**
-     * PAP: Retrieve a policy.
-     * @param policyId The id of the policy to retrieve.
-     * @returns The policy.
-     */
-    async papRetrieve(policyId) {
-        core.Guards.stringValue(this.CLASS_NAME, "policyId", policyId);
-        try {
-            const policy = await this._policyAdministrationPointComponent.retrieve(policyId);
-            return policy;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "papRetrieveFailed", undefined, error);
-        }
-    }
-    /**
-     * PAP: Remove a policy.
-     * @param policyId The id of the policy to remove.
-     * @returns Nothing.
-     */
-    async papRemove(policyId) {
-        core.Guards.stringValue(this.CLASS_NAME, "policyId", policyId);
-        try {
-            await this._policyAdministrationPointComponent.remove(policyId);
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "papRemoveFailed", undefined, error);
-        }
-    }
-    /**
-     * PAP: Query the policies using the specified conditions.
-     * @param conditions The conditions to use for the query.
-     * @param cursor The cursor to use for pagination.
-     * @param pageSize The number of results to return per page.
-     * @returns Cursor for next page of results and the policies matching the query.
-     */
-    async papQuery(conditions, cursor, pageSize) {
-        if (!core.Is.empty(conditions)) {
-            core.Guards.object(this.CLASS_NAME, "conditions", conditions);
-        }
-        if (!core.Is.empty(cursor)) {
-            core.Guards.stringValue(this.CLASS_NAME, "cursor", cursor);
-        }
-        if (!core.Is.empty(pageSize)) {
-            core.Guards.integer(this.CLASS_NAME, "pageSize", pageSize);
-        }
-        try {
-            const result = await this._policyAdministrationPointComponent.query(conditions, cursor, pageSize);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "papQueryFailed", undefined, error);
-        }
-    }
-    /**
-     * PEP: Process the data using Policy Decision Point (PDP) and return the manipulated data.
-     * @param assetType The type of asset being processed.
-     * @param action The action being performed on the asset.
-     * @param data The data to process.
-     * @param userIdentity The user identity to use in the decision making.
-     * @param nodeIdentity The node identity to use in the decision making.
-     * @returns The manipulated data with any policies applied.
-     */
-    async pepIntercept(assetType, action, data, userIdentity, nodeIdentity) {
-        core.Guards.stringValue(this.CLASS_NAME, "assetType", assetType);
-        core.Guards.stringValue(this.CLASS_NAME, "action", action);
-        try {
-            const result = await this._policyEnforcementPointComponent.intercept(assetType, action, data, userIdentity, nodeIdentity);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pepInterceptFailed", undefined, error);
-        }
-    }
+async function pnpNegotiationState(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.negotiationState(request.pathParams.policyId, request.body.nodeIdentity, request.body.proof);
+    return {
+        body: result
+    };
+}
+/**
+ * PNP: Negotiation Cancel.
+ * @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 pnpNegotiationCancel(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE, "request", request);
+    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+    const component = core.ComponentFactory.get(componentName);
+    await component.negotiationCancel(request.pathParams.policyId, request.body.nodeIdentity, request.body.proof);
+    return {
+        statusCode: web.HttpStatusCode.noContent
+    };
 }
 
 /**
@@ -521,20 +841,50 @@ class RightsManagementService {
  */
 const restEntryPoints = [
     {
-        name: "rights-management",
+        name: "policy-administration-point",
+        defaultBaseRoute: "rights-management",
+        tags: papTags,
+        generateRoutes: generateRestRoutesPolicyAdministrationPoint
+    },
+    {
+        name: "policy-enforcement-point",
+        defaultBaseRoute: "rights-management",
+        tags: pepTags,
+        generateRoutes: generateRestRoutesPolicyEnforcementPoint
+    },
+    {
+        name: "policy-negotiation-point",
+        defaultBaseRoute: "rights-management",
+        tags: pnpTags,
+        generateRoutes: generateRestRoutesPolicyNegotiationPoint
+    },
+    {
+        name: "policy-negotiation-admin-point",
         defaultBaseRoute: "rights-management",
-        tags,
-        generateRoutes: generateRestRoutesRightsManagement
+        tags: pnapTags,
+        generateRoutes: generateRestRoutesPolicyNegotiationAdminPoint
     }
 ];
 
-exports.RightsManagementService = RightsManagementService;
-exports.generateRestRoutesRightsManagement = generateRestRoutesRightsManagement;
+exports.generateRestRoutesPolicyAdministrationPoint = generateRestRoutesPolicyAdministrationPoint;
+exports.generateRestRoutesPolicyEnforcementPoint = generateRestRoutesPolicyEnforcementPoint;
+exports.generateRestRoutesPolicyNegotiationAdminPoint = generateRestRoutesPolicyNegotiationAdminPoint;
+exports.generateRestRoutesPolicyNegotiationPoint = generateRestRoutesPolicyNegotiationPoint;
 exports.papCreate = papCreate;
+exports.papGet = papGet;
 exports.papQuery = papQuery;
 exports.papRemove = papRemove;
-exports.papRetrieve = papRetrieve;
+exports.papTags = papTags;
 exports.papUpdate = papUpdate;
 exports.pepIntercept = pepIntercept;
+exports.pepTags = pepTags;
+exports.pnapGet = pnapGet;
+exports.pnapQuery = pnapQuery;
+exports.pnapRemove = pnapRemove;
+exports.pnapSet = pnapSet;
+exports.pnapTags = pnapTags;
+exports.pnpNegotiate = pnpNegotiate;
+exports.pnpNegotiationCancel = pnpNegotiationCancel;
+exports.pnpNegotiationState = pnpNegotiationState;
+exports.pnpTags = pnpTags;
 exports.restEntryPoints = restEntryPoints;
-exports.tags = tags;