#  ============LICENSE_START=======================================================
#  Copyright (C) 2024 OpenInfra Foundation Europe. All rights reserved.
#  ================================================================================
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
#
#  SPDX-License-Identifier: Apache-2.0
#  ============LICENSE_END=========================================================

openapi: 3.0.3
info:
  title: 'A1 policy management API'
  version: 1.0.0
  x-api-id: a31c510b-20e6-4a08-af16-368c44d7fba8
  x-audience: external-public
  description: "<h2>General</h2><p>The O-RAN Non-RT RIC Policy Management Service\
        \ provides a REST API for managemecnt of A1 policies. <br/>The main tasks of the\
        \ service are:</p><ul><li>A1 Policy creation, modification and deletion.</li><li>Monitoring\
        \ and maintaining consistency of the SMO view of A1 policies and the Near-RT RICs</li><li>Maintaining\
        \ a view of supported Near-RT RIC policy types</li><li>Supervision of using services\
        \ (R-APPs). When a service is unavailable, its policies are removed.</li></ul><h2>APIs\
        \ provided or defined by the service</h2><h3>A1 Policy Management</h3><p>This\
        \ is an API for management of A1 Policies.</p><ul><li>A1 Policy retrieval, creation,\
        \ modification and deletion.</li><li>Retrieval of supported A1 Policy types for\
        \ a Near-RT RIC</li><li>Retrieval of status for existing A1 policies</li></ul><h3>Management\
        \ of configuration</h3><p>API for updating and retrieval of the component configuration.\
        \ Note that there other ways to maintain the configuration.</p><h3>Service callbacks</h3><p>These\
        \ are endpoints that are invoked by this service. The callbacks are registered\
        \ in this service at service registration.</p><h3>NearRT-RIC Repository</h3><p>This\
        \ is an API that provides support for looking up a NearRT-RIC. Each A1 policy\
        \ is targeted for one Near-RT RIC.</p><h3>Health Check</h3><p>API used for supervision\
        \ of the PMS component.</p><h3>Service Registry and Supervision</h3><p>API used\
        \ for registering services that uses PMS. Each A1 policy is optionally owned by\
        \ a service. PMS can supervise each registered service by a heart-beat supervision\
        \ and will automatically remove policies for unavailable services. Note that a\
        \ service does not need to be registered in order to create A1 Policies. This\
        \ is a feature that is optional to use.</p><h3>Authorization API</h3><p>API used\
        \ for access control of A1 Policy access. If configured, an external authorization\
        \ provider is requested to grant access to the A1 Policy type.</p>"
  license:
    name: Copyright (C) 2024 OpenInfra Foundation Europe. Licensed under the Apache License.
    url: http://www.apache.org/licenses/LICENSE-2.0
  contact:
    url: https://www.onap.org/
    email: discuss-list@onap.com
servers:
  - url: '{apiRoot}/a1-policy-management/v1'
    variables:
      apiRoot:
        description: 'apiRoot is the Host:port/Domain name of the service  where the A1Pms running'
        default: 'https://a1-pms.com'
tags:
  - name: A1 Policy Management
    description: "API used to create polices, Policy Instances and get \ them as individual using an ID or get all policies/Instances."
  - name: NearRT-RIC Repository
    description: "API used to get the NearRT-RIC for the managed element."
  - name: Service Registry and Supervision
    description: "API used to keep the service Alive with in the timeout period"
  - name: Health Check
    description: "API used to get the health status and statistics of this service"
  - name: Service callbacks
  - name: Configuration
    description: "API used to create or fetch the application configuration."
paths:
  /status:
    get:
      operationId: getStatus
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StatusInfo'
              examples:
                status_info:
                  $ref: '#/components/examples/StatusInfo'
          description: OK- Service is living Ok
      description: Returns status and statistics of this service
      tags:
        - Health Check
  /rics/ric:
    get:
      description: Either a Near-RT RIC identity or a Managed Element identity can
        be specified.<br>The intention with Managed Element identity is the ID used
        in O1 for accessing the traffical element (such as the ID of CU).
      operationId: getRic
      parameters:
        - description: "The identity of a Managed Element. If given, the Near-RT RIC managing the ME is returned."
          explode: true
          in: query
          name: managedElementId
          required: false
          schema:
            type: string
          style: form
        - description: The identity of a Near-RT RIC to get information for.
          explode: true
          in: query
          name: ricId
          required: false
          schema:
            type: string
          style: form
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RicInfo'
              examples:
                ric_info:
                  $ref: '#/components/examples/RicInfo'
          description: OK - Near-RT RIC is found OK
        "404":
          $ref: '#/components/responses/404'
      summary: Returns info for one Near-RT RIC
      tags:
        - NearRT-RIC Repository
  /rics:
    get:
      description: The call returns all Near-RT RICs that supports a given policy
        type identity
      operationId: getRics
      parameters:
        - description: "The identity of a policy type. If given, all Near-RT RICs supporting the policy type are returned"
          explode: true
          in: query
          name: policyTypeId
          required: false
          schema:
            type: string
          style: form
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RicInfoList'
              examples:
                ric_info_list:
                  $ref: '#/components/examples/RicInfoList'
          description: OK
        "404":
          $ref: '#/components/responses/404'
      summary: Query Near-RT RIC information
      tags:
        - NearRT-RIC Repository
  /policy-types:
    get:
      operationId: getPolicyTypes
      parameters:
        - description: Select types for the given Near-RT RIC identity.
          explode: true
          in: query
          name: nearRtRicId
          required: false
          schema:
            type: string
          style: form
        - description: Select types with the given type name (type identity has the
            format <typename_version>)
          explode: true
          in: query
          name: typeName
          required: false
          schema:
            type: string
          style: form
        - description: Select types that are compatible with the given version. This
            parameter is only applicable in conjunction with type_name. As an example
            version 1.9.1 is compatible with 1.0.0 but not the other way around. Matching
            types will be returned sorted in ascending order.
          explode: true
          in: query
          name: compatibleWithVersion
          required: false
          schema:
            type: string
          style: form
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        '200':
          content:
            application/json:
              schema:
                items:
                  $ref: '#/components/schemas/PolicyTypeInformation'
                type: array

          description: OK - Policy Type IDs found Ok
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '406':
          $ref: '#/components/responses/406'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      description: Query policy type identities
      tags:
        - A1 Policy Management
  /policy-types/{policyTypeId}:
    get:
      operationId: getPolicyTypeDefinition
      parameters:
        - explode: false
          in: path
          name: policyTypeId
          required: true
          schema:
            type: string
          style: simple
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PolicyObject'
              examples:
                policyObject:
                  $ref: '#/components/examples/PolicyObject'
          description: OK - schema of the given policy type
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '406':
          $ref: '#/components/responses/406'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      description: Returns a policy type definition
      tags:
        - A1 Policy Management
  /policies/{policyId}:
    put:
      operationId: putPolicy
      parameters:
        - name: policyId
          in: path
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/PolicyObject'
            examples:
              policyObject:
                $ref: '#/components/examples/PolicyObject'
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PolicyObject'
          description: OK - Policy updated
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '406':
          $ref: '#/components/responses/406'
        '411':
          $ref: '#/components/responses/411'
        '413':
          $ref: '#/components/responses/413'
        '415':
          $ref: '#/components/responses/415'
        '423':
          $ref: '#/components/responses/Locked'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      description: update a policy
      tags:
        - A1 Policy Management
    delete:
      description: Deleting the policy using policyId.
      operationId: deletePolicy
      parameters:
        - explode: false
          in: path
          name: policyId
          required: true
          schema:
            type: string
          style: simple
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        '204':
          description: 'The created A1 policy was deleted'
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '423':
          $ref: '#/components/responses/Locked'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      summary: Delete a policy
      tags:
        - A1 Policy Management
    get:
      operationId: getPolicy
      parameters:
        - explode: false
          in: path
          name: policyId
          required: true
          schema:
            type: string
          style: simple
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PolicyObject'
              examples:
                policyObject:
                  $ref: '#/components/examples/PolicyObject'
          description: OK - Policy found
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '406':
          $ref: '#/components/responses/406'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      description: Returns a policy
      tags:
        - A1 Policy Management
  /policies:
    get:
      description: "Returns a list of A1 policies matching given search criteria.\
            \ <br>If several query parameters are defined, the policies matching all conditions\
            \ are returned."
      operationId: getAllPolicies
      parameters:
        - description: Select policies of a given policy type identity.
          explode: true
          in: query
          name: policyTypeId
          required: false
          schema:
            type: string
          style: form
        - description: Select policies of a given Near-RT RIC identity.
          explode: true
          in: query
          name: nearRtRicId
          required: false
          schema:
            type: string
          style: form
        - description: Select policies owned by a given service.
          explode: true
          in: query
          name: serviceId
          required: false
          schema:
            type: string
          style: form
        - description: Select policies of types with the given type name (type identity
            has the format <typename_version>)
          explode: true
          in: query
          name: typeName
          required: false
          schema:
            type: string
          style: form
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        '200':
          content:
            application/json:
              schema:
                items:
                  $ref: '#/components/schemas/PolicyInformation'
                type: array
          description: OK - Policy identities
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '406':
          $ref: '#/components/responses/406'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      summary: Query policy identities
      tags:
        - A1 Policy Management
    post:
      operationId: createPolicy
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/PolicyObjectInformation'
      responses:
        '201':
          description: 'Success case 201 created'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PolicyObjectInformation'
          headers:
            Location:
              description: 'Contains the URI of the newly created resource'
              required: true
              schema:
                type: string
        '400':
          $ref: '#/components/responses/400'
        '401':
          $ref: '#/components/responses/401'
        '403':
          $ref: '#/components/responses/403'
        '404':
          $ref: '#/components/responses/404'
        '406':
          $ref: '#/components/responses/406'
        '423':
          $ref: '#/components/responses/Locked'
        '429':
          $ref: '#/components/responses/429'
        '500':
          $ref: '#/components/responses/500'
        '502':
          $ref: '#/components/responses/502'
        '503':
          $ref: '#/components/responses/503'
      description: 'To create A1 policies'
      tags:
        - A1 Policy Management
  /configuration:
    get:
      operationId: getConfiguration
      responses:
        "200":
          content:
            application/json:
              schema:
                type: string
          description: OK - Application configuration received
        "404":
          $ref: '#/components/responses/404'

      description: Returns the contents of the application configuration
      tags:
        - Configuration
    put:
      operationId: putConfiguration
      requestBody:
        content:
          application/json:
            schema:
              type: object
        required: true
      responses:
        "200":
          content:
            '*/*':
              schema:
                $ref: '#/components/schemas/void'
          description: OK - Configuration updated
        "400":
          $ref: '#/components/responses/400'
      description: Replace the current configuration file with the given configuration
      tags:
        - Configuration
  /services/{serviceId}/keepalive:
    put:
      description: A registered service should invoke this operation regularly to
        indicate that it is still alive. If a registered service fails to invoke this
        operation before the end of a timeout period the service will be deregistered
        and all its A1 policies wil be removed. (This timeout can be set or disabled
        when each service is initially registered)
      operationId: keepAliveService
      parameters:
        - explode: false
          in: path
          name: serviceId
          required: true
          schema:
            type: string
          style: simple
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      requestBody:
        required: false
        content:
          application/json:
            schema:
              type: string
      responses:
        "200":
          content:
            '*/*':
              schema:
                type: object
          description: "OK - Service supervision timer refreshed, OK"
        "404":
          $ref: '#/components/responses/404'
      summary: Heartbeat indicates that the service is running
      tags:
        - Service Registry and Supervision
  /services:
    get:
      description: Either information about a registered service with given identity
        or all registered services are returned.
      operationId: getServices
      parameters:
        - description: The identity of the service
          explode: true
          in: query
          name: serviceId
          required: false
          schema:
            type: string
          style: form
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ServiceStatusList'
              examples:
                service_status_list:
                  $ref: '#/components/examples/ServiceStatusList'
          description: OK
        "404":
          $ref: '#/components/responses/404'
      summary: Returns service information
      tags:
        - Service Registry and Supervision
    put:
      description: "Registering a service is needed to:<ul><li>Get callbacks about\
            \ available NearRT RICs.</li><li>Activate supervision of the service. If a\
            \ service is inactive, its policies will automatically be deleted.</li></ul>Policies\
            \ can be created even if the service is not registerred. This is a feature\
            \ which it is optional to use."
      operationId: putService
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ServiceRegistrationInfo'
        required: true
      responses:
        "200":
          content:
            '*/*':
              schema:
                type: object
          description: OK - Service updated
        "201":
          content:
            '*/*':
              schema:
                type: object
          description: Created - Service created
        "400":
          $ref: '#/components/responses/400'
      summary: Register a service
      tags:
        - Service Registry and Supervision
      callbacks:
        RICStatus:
          "{$request.body#/callback_url}":
            post:
              description: The URL to this call is registered at Service registration.
              operationId: serviceCallback
              requestBody:
                content:
                  application/json:
                    schema:
                      $ref: '#/components/schemas/ServiceCallbackInfo'
                required: true
              responses:
                "200":
                  content:
                    application/json:
                      schema:
                        $ref: '#/components/schemas/void'
                  description: OK
                "404":
                  $ref: '#/components/responses/404'
              summary: Callback for Near-RT RIC status
              tags:
                - Service callbacks
  /services/{serviceId}:
    delete:
      operationId: deleteService
      parameters:
        - explode: false
          in: path
          name: serviceId
          required: true
          schema:
            type: string
          style: simple
        - description: Specifies the content type that the client expects to receive in response to the request.
            Only application/json is allowed.
          in: header
          name: Accept
          schema:
            type: string
            example: application/json
      responses:
        "204":
          content:
            '*/*':
              schema:
                type: object
          description: No Content - Service unregistered
        "404":
          $ref: '#/components/responses/404'
      description: Unregister a service
      tags:
        - Service Registry and Supervision
components:
  examples:
    ServiceStatusList:
      description: List of service information
      value:
        serviceList:
          - callbackUrl: callbackUrl
            serviceId: serviceId
            keepAliveIntervalSeconds: 0
            timeSinceLastActivitySeconds: 6
          - callbackUrl: callbackUrl
            serviceId: serviceId
            keepAliveIntervalSeconds: 0
            timeSinceLastActivitySeconds: 6
    PolicyStatusInfo:
      description: Status for one A1-P Policy
      value:
        lastModified: last_modified
        status:
          value:
            status: status
    StatusInfo:
      value:
        status: status
    RicInfo:
      value:
        ricId: ricId
        managedElementIds:
          - managedElementId
          - managedElementId
        state: UNAVAILABLE
        policyTypeIds:
          - policyTypeId
          - policyTypeId
    RicInfoList:
      value:
        rics:
          - ricId: ricId
            managedElementIds:
              - managedElementId
              - managedElementId
            state: UNAVAILABLE
            policyTypeIds:
              - policyTypeId
              - policyTypeId
          - ricId: ricId
            managedElementIds:
              - managedElementId
              - managedElementId
            state: UNAVAILABLE
            policyTypeIds:
              - policyTypeId
              - policyTypeId
    PolicyObject:
      value:
        scope:
          ueId:
            guRanUeId:
              globalGnbId:
                plmnId:
                  mcc: "123"
                  mnc: "45"
                gnbId:
                  gnbIdLength: 24
                  gnbIdValue: 12345678
              RanUeId: 'a31c510b20e64a74'
          groupId:
            spId: 123
          qosId:
            5qI: 1
          cellId:
            plmnId:
              mcc: "123"
              mnc: "45"
            cId:
              ncI: 123
        qosObjectives:
          gfbr: 100
          mfbr: 200
          priorityLevel: 3
          pdb: 50
  schemas:
    PolicyTypeInformation:
      description: >-
        Available policy types and for each policy type identifier the Near-RT
        RIC identifiers of those Near-RT RICs that support the related A1 policy
        type
      type: object
      properties:
        policyTypeId:
          description: Identity of the policy type
          type: string
        nearRtRicId:
          $ref: '#/components/schemas/NearRtRicId'
      required:
        - policyTypeId
        - nearRtRicId
    PolicyObjectInformation:
      description: Information related to the creation of the policy
      type: object
      properties:
        nearRtRicId:
          description: identity of the target Near-RT RIC
          type: string
          example:
            'Near-RT-Ric-ID'
        transient:
          default: false
          description: "if true, the policy is deleted at RIC restart. If false, its\
                \ value is maintained by this service until explicitly deleted. Default\
                \ false."
          nullable: false
          type: boolean
        policyId:
          description: identity of the Policy
          type: string
          example:
            'POLICY-ID'
        serviceId:
          description: the identity of the service owning the policy. This can be
            used to group the policies (it is possible to get all policies associated
            to a service). Note that the service does not need to be registered.
          type: string
          example:
            'rApp ID'
        policyObject:
          $ref: '#/components/schemas/PolicyObject'
        policyTypeId:
          description: identity of the policy type
          type: string
          example: 'ORAN_QOS_1.0.0(typeName_SemVersion)'
      required:
        - nearRtRicId
        - policyObject
        - policyTypeId
    ErrorInformation:
      description: Problem as defined in https://tools.ietf.org/html/rfc7807
      properties:
        detail:
          description: ' A human-readable explanation specific to this occurrence
                of the problem.'
          example: Policy type not found
          type: string
        title:
          description: 'A specific error name'
          type: string
          example: Not Found
        status:
          description: 'The HTTP status code generated by the origin server for this
                occurrence of the problem. '
          example: 404
          format: int32
          type: integer
      type: object
    PolicyObject:
      description: 'Policy Object is a JSON representation of an A1 policy'
      type: object
    void:
      description: Void/empty
      type: object
    StatusInfo:
      properties:
        status:
          description: status text
          type: string
      type: object
    AuthorizationResult:
      description: Result of authorization
      example:
        result: true
      properties:
        result:
          description: "If true, the access is granted"
          type: boolean
      required:
        - result
      type: object
    RicInfo:
      description: Information for a Near-RT RIC
      properties:
        ricId:
          description: identity of the Near-RT RIC
          type: string
        managedElementIds:
          description: O1 identities for managed entities
          items:
            description: O1 identities for managed entities
            type: string
          type: array
        state:
          description: Represents the states for a Near-RT RIC
          enum:
            - UNAVAILABLE
            - AVAILABLE
            - SYNCHRONIZING
            - CONSISTENCY_CHECK
          type: string
        policyTypeIds:
          description: supported policy types
          items:
            description: supported policy types
            type: string
          type: array
      type: object
    ServiceRegistrationInfo:
      description: Information for one service
      properties:
        callbackUrl:
          description: callback for notifying of Near-RT RIC state changes
          type: string
        serviceId:
          description: identity of the service
          type: string
        keepAliveIntervalSeconds:
          description: "keep alive interval for the service. This is used to enable\
                \ optional heartbeat supervision of the service. If set (> 0) the registered\
                \ service should regularly invoke a 'keepalive' REST call. When a service\
                \ fails to invoke this 'keepalive' call within the configured time, the\
                \ service is considered unavailable. An unavailable service will be automatically\
                \ deregistered and its policies will be deleted. Value 0 means timeout\
                \ supervision is disabled."
          format: int64
          type: integer
      required:
        - serviceId
      type: object
    PolicyStatusInfo:
      description: Status for one A1-P Policy
      properties:
        lastModified:
          description: "timestamp, last modification time"
          type: string
        status:
          description: the Policy status
          type: object
      type: object
    ServiceStatus:
      properties:
        callbackUrl:
          description: callback for notifying of RIC synchronization
          type: string
        serviceId:
          description: identity of the service
          type: string
        keepAliveIntervalSeconds:
          description: policy keep alive timeout
          format: int64
          type: integer
        timeSinceLastActivitySeconds:
          description: time since last invocation by the service
          format: int64
          type: integer
      type: object
    RicInfoList:
      description: List of Near-RT RIC information
      properties:
        rics:
          description: List of Near-RT RIC information
          items:
            $ref: '#/components/schemas/RicInfo'
          type: array
      type: object
    input:
      description: input
      properties:
        accessType:
          description: Access type
          enum:
            - READ
            - WRITE
            - DELETE
          type: string
        authToken:
          description: Authorization token
          type: string
        policyTypeId:
          description: Policy type identifier
          type: string
      required:
        - accessType
        - authToken
        - policyTypeId
      type: object
    PolicyAuthorization:
      description: Authorization request for A1 policy requests
      properties:
        input:
          $ref: '#/components/schemas/input'
      required:
        - input
      type: object
    NearRtRicId:
      description: Identity of the policy
      type: string
    PolicyInformation:
      description: >-
        Near-RT RIC identifiers where A1 policies exist and for each Near-RT RIC
        identifier the policy identifiers of those policies that exist in that
        Near-RT RIC
      type: object
      properties:
        policyId:
          description: Identity of the policy
          type: string
        nearRtRicId:
          $ref: '#/components/schemas/NearRtRicId'
      required:
        - policyId
        - nearRtRicId
    ServiceStatusList:
      properties:
        serviceList:
          description: List of service information
          items:
            $ref: '#/components/schemas/ServiceStatus'
          type: array
      type: object
    ServiceCallbackInfo:
      description: Information transferred as in Service callbacks (callback_url)
      properties:
        ricId:
          description: identity of a Near-RT RIC
          type: string
        eventType:
          description: "values:\nAVAILABLE: the  Near-RT RIC has become available\
                \ for A1 Policy management"
          enum:
            - AVAILABLE
          type: string
      required:
        - eventType
        - ricId
      type: object
    Link:
      properties:
        templated:
          type: boolean
        href:
          type: string
      type: object
    ProblemDetails:
      description: >-
        A problem detail to carry details in an HTTP response according to RFC
        7807
      type: object
      properties:
        type:
          description: >-
            a URI reference according to IETF RFC 3986 that identifies the
            problem type
          type: string
        title:
          description: human-readable summary of the problem type
          type: string
        status:
          description: the HTTP status code
          type: number
        detail:
          description: 'human-readable explanation '
          type: string
        instance:
          description: URI reference that identifies the specific occurrence of the problem
          type: string
  responses:
    '400':
      description: Bad Request
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '401':
      description: Unauthorized
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '403':
      description: Forbidden
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '404':
      description: Not Found
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '405':
      description: Method Not Allowed
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '406':
      description: Not Acceptable
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '409':
      description: Conflict
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '411':
      description: Length Required
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '413':
      description: Payload Too Large
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '415':
      description: Unsupported Media Type
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '429':
      description: Too Many Request
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '500':
      description: Internal Server Error
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '502':
      description: Bad Gateway
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    '503':
      description: Service Unavailable
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ProblemDetails'
    Locked:
      description: "Locked - HTTP Status code which can be used when the state is Locked"
      content:
        application/problem+json:
          schema:
            $ref: '#/components/schemas/ErrorInformation'
          example:
            status: 423
            title: Locked
            detail: State is Locked in the  provided request.