@twin.org/rights-management-service 0.0.2-next.5 → 0.0.2-next.7

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) {
+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),
@@ -74,7 +74,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
     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),
@@ -108,18 +108,18 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const papRetrieveRoute = {
-        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: "papRetrieveRequestExample",
+                    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,
@@ -155,7 +155,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
     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),
@@ -181,7 +181,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
     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),
@@ -227,10 +227,123 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
+    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),
@@ -270,147 +383,52 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const papNegotiateRoute = {
-        operationId: "pnpNegotiate",
-        summary: "Negotiate a policy",
-        tag: tags[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: tags[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: tags[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 [pepInterceptRoute];
+}
+/**
+ * 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 pepIntercept(httpRequestContext, componentName, request) {
+    core.Guards.object(ROUTES_SOURCE$2, "request", request);
+    const component = core.ComponentFactory.get(componentName);
+    const result = await component.intercept(request.body.assetType, request.body.action, {
+        ...(request.body.context ?? {}),
+        userIdentity: httpRequestContext.userIdentity,
+        nodeIdentity: httpRequestContext.nodeIdentity
+    }, request.body.data);
+    return {
+        body: result
     };
+}
+
+/**
+ * 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: tags[0].name,
+        tag: pnapTags[0].name,
         method: web.HttpMethod.GET,
         path: `${baseRouteName}/pnap/:policyId`,
         handler: async (httpRequestContext, request) => pnapGet(httpRequestContext, componentName, request),
@@ -449,7 +467,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
     const pnapSetRoute = {
         operationId: "pnapSet",
         summary: "Set a policy negotiation",
-        tag: tags[0].name,
+        tag: pnapTags[0].name,
         method: web.HttpMethod.PUT,
         path: `${baseRouteName}/pnap/:policyId`,
         handler: async (httpRequestContext, request) => pnapSet(httpRequestContext, componentName, request),
@@ -477,7 +495,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
     const pnapRemoveRoute = {
         operationId: "pnapRemove",
         summary: "Remove a policy negotiation",
-        tag: tags[0].name,
+        tag: pnapTags[0].name,
         method: web.HttpMethod.DELETE,
         path: `${baseRouteName}/pnap/:policyId`,
         handler: async (httpRequestContext, request) => pnapRemove(httpRequestContext, componentName, request),
@@ -497,7 +515,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
     const pnapQueryRoute = {
         operationId: "pnapQuery",
         summary: "Query policy negotiations",
-        tag: tags[0].name,
+        tag: pnapTags[0].name,
         method: web.HttpMethod.GET,
         path: `${baseRouteName}/pnap`,
         handler: async (httpRequestContext, request) => pnapQuery(httpRequestContext, componentName, request),
@@ -538,130 +556,237 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    return [
-        papCreateRoute,
-        papUpdateRoute,
-        papRetrieveRoute,
-        papRemoveRoute,
-        papQueryRoute,
-        pepInterceptRoute,
-        papNegotiateRoute,
-        papNegotiationStateRoute,
-        pnpNegotiationCancelRoute,
-        pnapGetRoute,
-        pnapSetRoute,
-        pnapRemoveRoute,
-        pnapQueryRoute
-    ];
+    return [pnapGetRoute, pnapSetRoute, pnapRemoveRoute, pnapQueryRoute];
 }
 /**
- * PAP: Create a policy.
+ * 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 papCreate(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
+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);
-    const policy = request.body;
-    const uid = await component.papCreate(policy);
+    const negotiation = await component.get(request.pathParams.policyId);
     return {
-        statusCode: web.HttpStatusCode.created,
-        headers: {
-            location: uid
-        }
+        body: negotiation
     };
 }
 /**
- * PAP: Update 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 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);
+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);
-    await component.papUpdate(request.body);
+    await component.set(request.body);
     return {
         statusCode: web.HttpStatusCode.noContent
     };
 }
 /**
- * PAP: Retrieve 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 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);
-    const component = core.ComponentFactory.get(componentName);
-    const policy = await component.papRetrieve(request.pathParams.id);
-    return {
-        body: policy
-    };
-}
-/**
- * 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.
- * @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.
+ * The source used when communicating about these routes.
  */
-async function pepIntercept(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.context ?? {}),
-        userIdentity: httpRequestContext.userIdentity,
-        nodeIdentity: httpRequestContext.nodeIdentity
-    }, request.body.data);
-    return {
-        body: result
+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.
@@ -673,7 +798,7 @@ 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.pnpNegotiate(request.body.assetType, request.body.action, request.body.resourceId, request.body.context, request.body.requesterInformation, request.body.proof);
+    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
     };
@@ -689,7 +814,7 @@ 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.pnpNegotiationState(request.pathParams.policyId, request.body.nodeIdentity, request.body.proof);
+    const result = await component.negotiationState(request.pathParams.policyId, request.body.nodeIdentity, request.body.proof);
     return {
         body: result
     };
@@ -705,372 +830,61 @@ 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.pnpNegotiationCancel(request.pathParams.policyId, request.body.nodeIdentity, request.body.proof);
-    return {
-        statusCode: web.HttpStatusCode.noContent
-    };
-}
-/**
- * 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 pnapGet(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.policyId", request.pathParams.policyId);
-    const component = core.ComponentFactory.get(componentName);
-    const negotiation = await component.pnapGet(request.pathParams.policyId);
-    return {
-        body: negotiation
-    };
-}
-/**
- * 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 pnapSet(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.policyId", request.pathParams.policyId);
-    core.Guards.object(ROUTES_SOURCE, "request.body", request.body);
-    const component = core.ComponentFactory.get(componentName);
-    await component.pnapSet(request.body);
-    return {
-        statusCode: web.HttpStatusCode.noContent
-    };
-}
-/**
- * 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 pnapRemove(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.policyId", request.pathParams.policyId);
-    const component = core.ComponentFactory.get(componentName);
-    await component.pnapRemove(request.pathParams.policyId);
+    await component.negotiationCancel(request.pathParams.policyId, request.body.nodeIdentity, request.body.proof);
     return {
         statusCode: web.HttpStatusCode.noContent
     };
 }
-/**
- * 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 pnapQuery(httpRequestContext, componentName, request) {
-    core.Guards.object(ROUTES_SOURCE, "request", request);
-    const component = core.ComponentFactory.get(componentName);
-    const result = await component.pnapQuery(request.query?.status, request.query?.cursor);
-    return {
-        body: {
-            items: result.items,
-            cursor: result.cursor
-        }
-    };
-}
-
-// 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.
- */
-class RightsManagementService {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "RightsManagementService";
-    /**
-     * The PAP component implementation.
-     * @internal
-     */
-    _policyAdministrationPointComponent;
-    /**
-     * The PEP component implementation.
-     * @internal
-     */
-    _policyEnforcementPointComponent;
-    /**
-     * The PNP component implementation.
-     * @internal
-     */
-    _policyNegotiationPointComponent;
-    /**
-     * The PNAP component implementation.
-     * @internal
-     */
-    _policyNegotiationAdminPointComponent;
-    /**
-     * 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");
-        this._policyNegotiationPointComponent = core.ComponentFactory.get(options?.policyNegotiationPointComponentType ?? "policy-negotiation-point");
-        this._policyNegotiationAdminPointComponent =
-            core.ComponentFactory.get(options?.policyNegotiationAdminPointComponentType ?? "policy-negotiation-admin-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 context The context to use in the decision making.
-     * @param data The data to process.
-     * @returns The manipulated data with any policies applied.
-     */
-    async pepIntercept(assetType, action, context, data) {
-        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, context, data);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pepInterceptFailed", undefined, error);
-        }
-    }
-    /**
-     * PNP: Negotiates the creation of a policy for the requested resource.
-     * @param assetType The type of asset being processed.
-     * @param action The action being performed on the asset.
-     * @param resourceId The ID of the resource being requested, can be empty if asset type access requested.
-     * @param context The context from the requesting node.
-     * @param requesterInformation Information provided by the requester to determine if a policy can be created.
-     * @param proof The proof provided by the requester to support the policy creation.
-     * @returns The state of the policy.
-     */
-    async pnpNegotiate(assetType, action, resourceId, context, requesterInformation, proof) {
-        core.Guards.stringValue(this.CLASS_NAME, "assetType", assetType);
-        core.Guards.stringValue(this.CLASS_NAME, "action", action);
-        core.Guards.stringValue(this.CLASS_NAME, "resourceId", resourceId);
-        core.Guards.object(this.CLASS_NAME, "proof", proof);
-        try {
-            const result = await this._policyNegotiationPointComponent.negotiate(assetType, action, resourceId, context, requesterInformation, proof);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnpNegotiateFailed", undefined, error);
-        }
-    }
-    /**
-     * PNP: Retrieves the current state of a policy.
-     * @param policyId The ID of the policy to retrieve the state for.
-     * @param nodeIdentity The identity of the node requesting the state.
-     * @param proof The proof provided by the requester.
-     * @returns The current state of the policy.
-     */
-    async pnpNegotiationState(policyId, nodeIdentity, proof) {
-        core.Guards.stringValue(this.CLASS_NAME, "policyId", policyId);
-        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        core.Guards.object(this.CLASS_NAME, "proof", proof);
-        try {
-            const result = await this._policyNegotiationPointComponent.negotiationState(policyId, nodeIdentity, proof);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnpNegotiationState", undefined, error);
-        }
-    }
-    /**
-     * PNP: Cancels an ongoing negotiation for a resource.
-     * @param policyId The ID of the policy to cancel.
-     * @param nodeIdentity The identity of the node requesting the cancellation.
-     * @param proof The proof provided by the requester.
-     * @returns Nothing.
-     */
-    async pnpNegotiationCancel(policyId, nodeIdentity, proof) {
-        core.Guards.stringValue(this.CLASS_NAME, "policyId", policyId);
-        core.Guards.stringValue(this.CLASS_NAME, "nodeIdentity", nodeIdentity);
-        core.Guards.object(this.CLASS_NAME, "proof", proof);
-        try {
-            await this._policyNegotiationPointComponent.negotiationCancel(policyId, nodeIdentity, proof);
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnpNegotiationCancelFailed", undefined, error);
-        }
-    }
-    /**
-     * PNAP: Retrieves a policy negotiation.
-     * @param policyId The ID of the policy to retrieve the negotiation for.
-     * @returns The policy negotiation.
-     */
-    async pnapGet(policyId) {
-        core.Guards.stringValue(this.CLASS_NAME, "policyId", policyId);
-        try {
-            return this._policyNegotiationAdminPointComponent.get(policyId);
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnapGetFailed", undefined, error);
-        }
-    }
-    /**
-     * PNAP: Sets a policy negotiation.
-     * @param negotiation The updated policy negotiation.
-     * @returns Nothing.
-     */
-    async pnapSet(negotiation) {
-        core.Guards.object(this.CLASS_NAME, "negotiation", negotiation);
-        try {
-            return this._policyNegotiationAdminPointComponent.set(negotiation);
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnapSetFailed", undefined, error);
-        }
-    }
-    /**
-     * PNAP: Removes a policy negotiation record.
-     * @param policyId The ID of the policy negotiation to remove.
-     * @returns Nothing.
-     */
-    async pnapRemove(policyId) {
-        core.Guards.stringValue(this.CLASS_NAME, "policyId", policyId);
-        try {
-            await this._policyNegotiationAdminPointComponent.remove(policyId);
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnapRemoveFailed", undefined, error);
-        }
-    }
-    /**
-     * PNAP: Get a list of the negotiations.
-     * @param status The state of the negotiations to retrieve.
-     * @param cursor The cursor to use for pagination.
-     * @returns A list of negotiations and cursor if there are more entries.
-     */
-    async pnapQuery(status, cursor) {
-        try {
-            const result = await this._policyNegotiationAdminPointComponent.query(status, cursor);
-            return result;
-        }
-        catch (error) {
-            throw new core.GeneralError(this.CLASS_NAME, "pnapQueryFailed", undefined, error);
-        }
-    }
-}
 
 /**
  * Entry points for the REST API.
  */
 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;