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

package/dist/cjs/index.cjs

@@ -27,7 +27,7 @@ const tags = [
  * @returns The generated routes.
  */
 function generateRestRoutesRightsManagement(baseRouteName, componentName) {
-    const createRoute = {
+    const papCreateRoute = {
         operationId: "papCreate",
         summary: "Create a policy",
         tag: tags[0].name,
@@ -38,7 +38,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapCreateRequest",
             examples: [
                 {
-                    id: "papCreateExample",
+                    id: "papCreateRequestExample",
                     request: {
                         body: {
                             "@context": standardsW3cOdrl.OdrlContexts.ContextRoot,
@@ -71,7 +71,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const updateRoute = {
+    const papUpdateRoute = {
         operationId: "papUpdate",
         summary: "Update a policy",
         tag: tags[0].name,
@@ -82,7 +82,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapUpdateRequest",
             examples: [
                 {
-                    id: "papUpdateExample",
+                    id: "papUpdateRequestExample",
                     request: {
                         pathParams: {
                             id: "urn:rights-management:abc123def456"
@@ -108,7 +108,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const retrieveRoute = {
+    const papRetrieveRoute = {
         operationId: "papRetrieve",
         summary: "Retrieve a policy",
         tag: tags[0].name,
@@ -119,7 +119,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapRetrieveRequest",
             examples: [
                 {
-                    id: "papRetrieveExample",
+                    id: "papRetrieveRequestExample",
                     request: {
                         pathParams: {
                             id: "urn:rights-management:abc123def456"
@@ -152,7 +152,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const removeRoute = {
+    const papRemoveRoute = {
         operationId: "papRemove",
         summary: "Remove a policy",
         tag: tags[0].name,
@@ -163,7 +163,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapRemoveRequest",
             examples: [
                 {
-                    id: "papRemoveExample",
+                    id: "papRemoveRequestExample",
                     request: {
                         pathParams: {
                             id: "urn:rights-management:abc123def456"
@@ -178,7 +178,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const queryRoute = {
+    const papQueryRoute = {
         operationId: "papQuery",
         summary: "Query policies",
         tag: tags[0].name,
@@ -189,7 +189,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPapQueryRequest",
             examples: [
                 {
-                    id: "papQueryExample",
+                    id: "papQueryRequestExample",
                     request: {
                         query: {
                             cursor: "optional-pagination-cursor"
@@ -227,7 +227,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    const interceptRoute = {
+    const pepInterceptRoute = {
         operationId: "pepIntercept",
         summary: "Intercept a request",
         tag: tags[0].name,
@@ -238,7 +238,7 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             type: "IPepInterceptRequest",
             examples: [
                 {
-                    id: "pepInterceptExample",
+                    id: "pepInterceptRequestExample",
                     request: {
                         body: {
                             assetType: "document",
@@ -270,7 +270,289 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
             }
         ]
     };
-    return [createRoute, updateRoute, retrieveRoute, removeRoute, queryRoute, interceptRoute];
+    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
+    };
+    const pnapGetRoute = {
+        operationId: "pnapGet",
+        summary: "Get a policy negotiation",
+        tag: tags[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: tags[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: tags[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: tags[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 [
+        papCreateRoute,
+        papUpdateRoute,
+        papRetrieveRoute,
+        papRemoveRoute,
+        papQueryRoute,
+        pepInterceptRoute,
+        papNegotiateRoute,
+        papNegotiationStateRoute,
+        pnpNegotiationCancelRoute,
+        pnapGetRoute,
+        pnapSetRoute,
+        pnapRemoveRoute,
+        pnapQueryRoute
+    ];
 }
 /**
  * PAP: Create a policy.
@@ -282,7 +564,6 @@ function generateRestRoutesRightsManagement(baseRouteName, componentName) {
 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);
     const component = core.ComponentFactory.get(componentName);
     const policy = request.body;
     const uid = await component.papCreate(policy);
@@ -305,7 +586,6 @@ async function papUpdate(httpRequestContext, componentName, 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);
     const component = core.ComponentFactory.get(componentName);
     await component.papUpdate(request.body);
     return {
@@ -323,7 +603,6 @@ 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);
     const component = core.ComponentFactory.get(componentName);
     const policy = await component.papRetrieve(request.pathParams.id);
     return {
@@ -375,11 +654,132 @@ async function papQuery(httpRequestContext, componentName, request) {
 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.data, httpRequestContext.userIdentity ?? "", httpRequestContext.nodeIdentity ?? "");
+    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
+    };
+}
+/**
+ * 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 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);
     return {
         body: result
     };
 }
+/**
+ * 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.
+ */
+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);
+    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.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);
+    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.
@@ -402,6 +802,16 @@ class RightsManagementService {
      * @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.
@@ -410,6 +820,9 @@ class RightsManagementService {
         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.
@@ -498,22 +911,138 @@ class RightsManagementService {
      * 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.
-     * @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) {
+    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, data, userIdentity, nodeIdentity);
+            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);
+        }
+    }
 }
 
 /**
@@ -536,5 +1065,12 @@ exports.papRemove = papRemove;
 exports.papRetrieve = papRetrieve;
 exports.papUpdate = papUpdate;
 exports.pepIntercept = pepIntercept;
+exports.pnapGet = pnapGet;
+exports.pnapQuery = pnapQuery;
+exports.pnapRemove = pnapRemove;
+exports.pnapSet = pnapSet;
+exports.pnpNegotiate = pnpNegotiate;
+exports.pnpNegotiationCancel = pnpNegotiationCancel;
+exports.pnpNegotiationState = pnpNegotiationState;
 exports.restEntryPoints = restEntryPoints;
 exports.tags = tags;