module A1-ADAPTER-API {

    namespace "org:onap:ccsdk";

    prefix a1-adapter-api;

    revision "2019-12-12" {
        description
        "Added standard output payload for all RPC's";
    }

    revision "2019-10-02" {
        description
        "A1 adapter for Frankfurt";
    }

    grouping a1-adapter-response {
      leaf response-code {
        type string;
      }
      leaf response-message {
        type string;
      }
      description
        "Response payload for A1 Adapter RPC's";
    }

    grouping a1-policy-instance-property {

      description
        "Properties as specified in the create_schema field of policy type in PUT payload";

      leaf property-name {
        type string {
          length "1..64";
        }
        description
          "Individual property name";
      }
      leaf property-value {
        type string {
          length "1..64";
        }
        description
          "Value of the property";
      }
    }


    grouping a1-policy-type-create-schema-property-statement {

      leaf policy-statement {
        type string {
          length "1..64";
        }
        description
          "Individual policy statement name";
      }
      leaf policy-statement-value {
        type string {
          length "1..64";
        }
        description
          "Value of the policy statement";
      }
    }


///Flattend interface using RPC

    //Get a comma separated list of near-rt rics, e.g. domain-name1:port1,domainname2:port2
    //Each item in the returned list will be regarded as one near-rt-ric-id.
    rpc getNearRT-RICs {
        // OpenDaylight Fluorine version of restconf cannot handle RPCs with no input
        input {
          leaf dummy {
            type string;
          }
        }

        output {
            uses a1-adapter-response;
            leaf-list near-rt-ric-id-list {
                type string;
            }
        }
    }

    //Get health status for a Near-RT-RIC. true - health ok, false - health is not ok.
    rpc getHealthCheck {
         input {
            leaf near-rt-ric-id {
                type string;
            }
        }

        output {
            uses a1-adapter-response;
            leaf health-status {
                type boolean;
            }
        }
    }

    //Get a comma separated list of integer policy type ids
    //Each item in the returned list will be regarded as one policy-type-id.
    rpc getPolicyTypes {
        input {
            leaf near-rt-ric-id {
                type string;
            }
        }
        output {
            uses a1-adapter-response;
            leaf-list policy-type-id-list {
                type uint32;
            }
        }
    }

    //Create a policy type
    rpc createPolicyType {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
            leaf description {
                type string;
            }
            leaf name {
                type string;
            }
            leaf policy-type {
                type string;
            }
            list properties {
                key "property-name";
                leaf property-name {
                  type string {
                    length "1..64";
                  }
                  description
                    "Individual property name";
                }
                list policy-statements {
                  key "policy-statement";
                  uses a1-policy-type-create-schema-property-statement;
                }
            }
          }
       output {
            uses a1-adapter-response;
            leaf status {
                type string;
            }
            leaf code {
                type string;
            }
        }
    }

    //Get a policy type
    rpc getPolicyType {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
        }
        output {
            uses a1-adapter-response;
            leaf description {
                type string;
            }
            leaf name {
                type string;
            }
            leaf policy-type {
                type string;
            }
        }
    }

    //Delete a policy type
    rpc deletePolicyType {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
        }
        output {
            uses a1-adapter-response;
            }
    }

    //Get a comma separeated list of string policy instance ids
    //Each item in the returned list will be regarded as one policy-instance-id.
    rpc getPolicyInstances {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
        }

        output {
            uses a1-adapter-response;
            leaf-list policy-instance-id-list {
                type string;
            }
        }
    }

    //Create a policy instance
    rpc createPolicyInstance {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
            leaf policy-instance-id {
                type string;
            }
            leaf policy-instance {
                type string;
            }
            list properties {
                key "property-name";
                uses a1-policy-instance-property;
            }
        }
        output {
        uses a1-adapter-response;
          }
    }

    ///Get a policy instance
    rpc getPolicyInstance {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
            leaf policy-instance-id {
                type string;
            }
        }
        output {
            uses a1-adapter-response;
            leaf policy-instance {
                type string;
            }
        }
    }

    //Delete a policy instance
    rpc deletePolicyInstance {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
            leaf policy-instance-id {
                type string;
            }
        }
        output {
           uses a1-adapter-response;
        }
    }

    //Get the status for a policy instance
    rpc getStatus {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
            leaf policy-instance-id {
                type string;
            }
        }
        output {
            uses a1-adapter-response;
            leaf status {
                type string;
            }
        }
    }

    //Policy feedback Notification to provide policy enforcement update
    rpc notifyPolicyEnforcementUpdate {
        input {
            leaf near-rt-ric-id {
                type string;
            }
            leaf policy-type-id {
                type uint32;
            }
            leaf policy-instance-id {
                type string;
            }
            leaf policy_enforcement_status {
                type string;
                description
                  "Policy enforcement status - IN_EFFECT or NON_IN_EFFECT";
            }
            leaf policy_enforcement_reason {
                type string;
                description
                  "Indicates the reason why policy is no longer being enforced";
            }
        }
        output {
            uses a1-adapter-response;
        }
    }




}