module junos-rpc-security {

    yang-version 1;

    namespace
      "http://yang.juniper.net/junos/rpc/security";

    prefix security;

    import junos-common-types {
      prefix jt;
      revision-date "2019-01-01";
    }

    organization "Juniper Networks, Inc.";

    contact "yang-support@juniper.net";

    description
      "Junos RPC YANG module for security command(s)";

    revision "2019-01-01" {
      description "Junos: 21.3R1.9";
    }


    rpc get-security-alarm-information {
      description
        "Show active security alarm information";
      input {
        leaf alarm-id {
          type union {
            type uint32;
            type string {
              pattern "<.*>|$.*";
            }
          }
          description "Alarm ID filter";
        }

        leaf-list alarm-type {
          type enumeration {
            enum "authentication" {
              value 0;
              description
                "Authentication alarms";
            }
            enum "cryptographic-self-test" {
              value 1;
              description
                "Cryptographic self-test alarms";
            }
            enum "decryption-failures" {
              value 2;
              description
                "Decryption failure alarms";
            }
            enum "encryption-failures" {
              value 3;
              description
                "Encryption failure alarms";
            }
            enum "ike-phase1-failures" {
              value 4;
              description
                "IKE Phase 1 failure alarms";
            }
            enum "ike-phase2-failures" {
              value 5;
              description
                "IKE Phase 2 failure alarms";
            }
            enum "key-generation-self-test" {
              value 6;
              description
                "Key generation self-test alarms";
            }
            enum
              "non-cryptographic-self-test" {
              value 7;
              description
                "Non-cryptographic self-test alarms";
            }
            enum "policy" {
              value 8;
              description "Policy alarms";
            }
            enum "replay-attacks" {
              value 9;
              description
                "Replay attack alarms";
            }
            enum "idp" {
              value 10;
              description
                "IDP attack alarms";
            }
          }
          ordered-by user;
          description "Alarm type filter";
        }

        leaf newer-than {
          type jt:time;
          description
            "Alarms newer than filter (YYYY-MM-DD.HH:MM:SS)";
        }

        leaf older-than {
          type jt:time;
          description
            "Alarms older than filter (YYYY-MM-DD.HH:MM:SS)";
        }

        leaf process {
          type string;
          description
            "Process that generated the alarm filter";
        }

        leaf severity {
          type enumeration {
            enum "alert" {
              value 0;
              description "Alert severity";
            }
            enum "crit" {
              value 1;
              description
                "Critical severity";
            }
            enum "debug" {
              value 2;
              description "Debug severity";
            }
            enum "emerg" {
              value 3;
              description
                "Emergency severity";
            }
            enum "err" {
              value 4;
              description "Error severity";
            }
            enum "info" {
              value 5;
              description
                "Information severity";
            }
            enum "notice" {
              value 6;
              description "Notice severity";
            }
            enum "warning" {
              value 7;
              description "Warning severity";
            }
          }
          description
            "Severity of the alarm filter";
        }

        leaf style {
          type enumeration {
            enum "detail" {
              value 0;
              description
                "Show detail alarm information";
            }
          }
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml security-alarm-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-security-alarm-information

    rpc get-security-log-information {
      description
        "Show auditable security log information";
      input {
        leaf destination-address {
          type jt:ipprefix-optional;
          description
            "Destination address and optional prefix length";
        }

        leaf destination-port {
          type union {
            type uint32;
            type string {
              pattern "<.*>|$.*";
            }
          }
          description "Destination port";
        }

        leaf event-id {
          type string;
          description "Event ID filter";
        }

        leaf interface-name {
          type string;
          description "Name of interface";
        }

        leaf older-than {
          type jt:time;
          description
            "Events older than filter (YYYY-MM-DD.HH:MM:SS)";
        }

        leaf policy-name {
          type string;
          description "Policy name filter";
        }

        leaf process {
          type string;
          description
            "Process that generated the event";
        }

        leaf protocol {
          type string;
          description "Protocol filter";
        }

        leaf newer-than {
          type jt:time;
          description
            "Events newer than filter (YYYY-MM-DD.HH:MM:SS)";
        }

        leaf result {
          type enumeration {
            enum "failure" {
              value 0;
              description
                "Event was a failure";
            }
            enum "success" {
              value 1;
              description
                "Event was successful";
            }
          }
        }

        leaf severity {
          type enumeration {
            enum "alert" {
              value 0;
              description "Alert severity";
            }
            enum "crit" {
              value 1;
              description
                "Critical severity";
            }
            enum "debug" {
              value 2;
              description "Debug severity";
            }
            enum "emerg" {
              value 3;
              description
                "Emergency severity";
            }
            enum "err" {
              value 4;
              description "Error severity";
            }
            enum "info" {
              value 5;
              description
                "Information severity";
            }
            enum "notice" {
              value 6;
              description "Notice severity";
            }
            enum "warning" {
              value 7;
              description "Warning severity";
            }
          }
          description
            "Severity of the event";
        }

        leaf source-address {
          type jt:ipprefix-optional;
          description
            "Source address and optional prefix length";
        }

        leaf source-port {
          type union {
            type uint32;
            type string {
              pattern "<.*>|$.*";
            }
          }
          description "Source port";
        }

        leaf username {
          type string;
          description "Username filter";
        }

        leaf sort-by {
          type enumeration {
            enum "destination-address" {
              value 0;
              description
                "Sort by destination address";
            }
            enum "destination-port" {
              value 1;
              description
                "Sort by destination port";
            }
            enum "interface-name" {
              value 2;
              description
                "Sort by interface name";
            }
            enum "policy-name" {
              value 3;
              description
                "Sort by policy name";
            }
            enum "protocol" {
              value 4;
              description "Sort by protocol";
            }
            enum "source-address" {
              value 5;
              description
                "Sort by source address";
            }
            enum "source-port" {
              value 6;
              description
                "Sort by source port";
            }
            enum "time" {
              value 7;
              description
                "Sort by time of event arrival";
            }
            enum "username" {
              value 8;
              description
                "Sort by event user name ";
            }
          }
          default "time";
          description
            "Sort by selected field";
        }

        leaf direction {
          type enumeration {
            enum "ascending" {
              value 0;
              description
                "Sort in ascending order";
            }
            enum "descending" {
              value 1;
              description
                "Sort in descending order";
            }
          }
          default "ascending";
        }

        leaf style {
          type enumeration {
            enum "detail" {
              value 0;
              description
                "Show detail alarm information";
            }
          }
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml security-log-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-security-log-information

    rpc get-pki-certificate-request {
      description
        "Show PKCS-10 certificate request information";
      input {
        uses command-forwarding;

        choice daemon-select {
          case logical-system {
          }  // case logical-system
        }  // choice daemon-select

        leaf certificate-id {
          type string {
            length "1 .. 32";
          }
          description
            "Certificate identifier";
        }

        leaf level {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml x509-pki-certificate-info-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-pki-certificate-request

    rpc get-pki-ca-certificate {
      description
        "Show certificate-authority certificate information";
      input {
        uses command-forwarding;

        choice daemon-select {
          case logical-system {
          }  // case logical-system
        }  // choice daemon-select

        choice ca-cert-choice {
          leaf ca-profile {
            type string {
              length "1 .. 32";
            }
            description
              "Certificate authority profile";
          }
          leaf ca-profile-group {
            type string {
              length "1 .. 32";
            }
            description
              "Show CA profile group";
          }
        }  // choice ca-cert-choice

        leaf level {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml x509-pki-certificate-info-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-pki-ca-certificate

    rpc get-node-local-local-certificate {
      description
        "Show router certificate information";
      input {
        uses command-forwarding;

        choice daemon-select {
          case logical-system {
          }  // case logical-system
        }  // choice daemon-select

        choice certificate-choice {
          leaf certificate-id {
            type string {
              length "1 .. 32";
            }
            description
              "Certificate identifier";
          }
          leaf system-generated {
            type empty;
            description
              "Autogenerated self-signed certificate";
          }
        }  // choice certificate-choice

        leaf level {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml x509-pki-certificate-info-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-node-local-local-certificate

    rpc get-node-local-certificate-request {
      description
        "Show PKCS-10 certificate request information";
      input {
        uses command-forwarding;

        choice daemon-select {
          case logical-system {
          }  // case logical-system
        }  // choice daemon-select

        leaf certificate-id {
          type string {
            length "1 .. 32";
          }
          description
            "Certificate identifier";
        }

        leaf level {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml x509-pki-certificate-info-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-node-local-certificate-request

    rpc get-pki-local-certificate {
      description
        "Show router certificate information";
      input {
        uses command-forwarding;

        choice daemon-select {
          case logical-system {
          }  // case logical-system
        }  // choice daemon-select

        choice certificate-choice {
          leaf certificate-id {
            type string {
              length "1 .. 32";
            }
            description
              "Certificate identifier";
          }
          leaf system-generated {
            type empty;
            description
              "Autogenerated self-signed certificate";
          }
        }  // choice certificate-choice

        leaf level {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml x509-pki-certificate-info-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-pki-local-certificate

    rpc get-pki-crl {
      description
        "Show certificate revocation list information";
      input {
        uses command-forwarding;

        choice daemon-select {
          case logical-system {
          }  // case logical-system
        }  // choice daemon-select

        leaf ca-profile {
          type string {
            length "1 .. 32";
          }
          description
            "Certificate authority profile";
        }

        leaf level {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml x509-pkid-crl-information-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-pki-crl

    rpc get-idp-application-system-cache {
      description
        "Show IDP application system cache";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-application-system-cache-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-application-system-cache

    rpc get-idp-active-policy {
      status deprecated;
      description "Show active IDP policy";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-version-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-active-policy

    rpc get-idp-policy-commit-status {
      description
        "Show the status of ongoing policy compilation and load";
      input {
        uses command-forwarding;

        choice re-selector-idpd {
          case re0 {
          }  // case re0

          case re1 {
          }  // case re1
        }  // choice re-selector-idpd

        leaf clear {
          type empty;
          description
            "Clears the policy commit status";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-policy-commit-status;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-policy-commit-status

    rpc get-idp-security-package-proxy-information {
      description
        "Show proxy profile details";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-security-package-proxy-profile;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-security-package-proxy-information

    rpc get-idp-security-package-information {
      description
        "Show the version of currently installed security-package";
      input {
        uses command-forwarding;

        choice re-selector-idpd {
          case re0 {
          }  // case re0

          case re1 {
          }  // case re1
        }  // choice re-selector-idpd
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-security-package-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-security-package-information

    rpc get-idp-jist-package-information {
      description
        "Show the version of currently installed JIST package";
      input {
        uses command-forwarding;

        choice re-selector-idpd {
          case re0 {
          }  // case re0

          case re1 {
          }  // case re1
        }  // choice re-selector-idpd
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-jist-package-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-jist-package-information

    rpc get-idp-recent-security-package-information {
      description
        "List ten most recent security package versions";
      input {
        uses command-forwarding;

        choice re-selector-idpd {
          case re0 {
          }  // case re0

          case re1 {
          }  // case re1
        }  // choice re-selector-idpd
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-recent-security-package-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-recent-security-package-information

    rpc get-idp-memory-information {
      description
        "Show IDP data plane memory statistics";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-memory-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-memory-information

    rpc get-idp-subscriber-policy-list {
      description
        "Show the currently used policies";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-subscriber-policy-list;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-subscriber-policy-list

    rpc get-idp-policy-template-information {
      description
        "Show available policy templates";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-policy-template-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-policy-template-information

    rpc get-idp-status-information {
      description "Show IDP status";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-status-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-status-information

    rpc get-idp-detail-status-information {
      description "Show IDP detail status";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-detail-status-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-detail-status-information

    rpc get-idp-predefined-attack-groups {
      description
        "Show predefined attack groups";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-predefined-attack-groups;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-predefined-attack-groups

    rpc get-idp-predefined-attack-group-filters {
      description "Configure filters";
      input {
        uses command-forwarding;

        choice re-selector-idpd {
          case re0 {
          }  // case re0

          case re1 {
          }  // case re1
        }  // choice re-selector-idpd

        leaf category {
          type string;
          description
            "Category of attack group";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-predefined-attack-group-filters;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-predefined-attack-group-filters

    rpc get-idp-predefined-attacks {
      description "Show predefined attacks";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-predefined-attacks;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-predefined-attacks

    rpc get-idp-predefined-attack-filters {
      description "Configure filters";
      input {
        uses command-forwarding;

        choice re-selector-idpd {
          case re0 {
          }  // case re0

          case re1 {
          }  // case re1
        }  // choice re-selector-idpd

        leaf category {
          type string;
          description "Category of attack";
        }

        leaf severity {
          type enumeration {
            enum "info" {
              value 0;
              description
                "Provide information of attack when it matches";
            }
            enum "warning" {
              value 1;
              description
                "The attack is a minor one";
            }
            enum "minor" {
              value 2;
              description
                "The attack is a minor one";
            }
            enum "major" {
              value 3;
              description
                "The attack is a major one";
            }
            enum "critical" {
              value 4;
              description
                "The attack is a critical one";
            }
          }
          description "Severity of attack";
        }

        leaf direction {
          type enumeration {
            enum "client-to-server" {
              value 0;
              description
                "Select attacks from client to server";
            }
            enum "server-to-client" {
              value 1;
              description
                "Select attacks from server to client";
            }
            enum "any" {
              value 2;
              description
                "Select attacks which can occur in either direction";
            }
            enum "exclude-client-to-server" {
              value 3;
              description
                "Filter out attacks from client to server";
            }
            enum "exclude-server-to-client" {
              value 4;
              description
                "Filter out attacks from server to client";
            }
            enum "exclude-any" {
              value 5;
              description
                "Filter out attacks which are in any direction";
            }
          }
          description "Direction of attack";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-predefined-attack-filters;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-predefined-attack-filters

    rpc get-idp-counter-information {
      description "Show IDP counters";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-counter-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counter-information

    rpc get-idp-counters-packet {
      description "Show IDP Packet counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-packet

    rpc get-idp-counters-tcp-reass {
      description
        "Show IDP Reassembler counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-tcp-reass

    rpc get-idp-counters-ips {
      description "Show IPS counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-ips

    rpc get-idp-counters-flow {
      description "Show IDP Flow counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-flow

    rpc get-idp-counters-dfa {
      description "Show IDP DFA counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-dfa

    rpc get-idp-counters-log {
      description "Show IDP Log counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-log

    rpc get-idp-counters-pol-mngr {
      description "Show IDP Policy counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-pol-mngr

    rpc get-idp-counters-packet-log {
      description
        "Show IDP Packet capture counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-packet-log

    rpc get-idp-counters-appid {
      description
        "Show Application Identification counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-appid

    rpc get-idp-counters-memory {
      description "Show IDP memory counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-memory

    rpc get-idp-counters-action {
      description
        "Show IDP policy action counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-action

    rpc get-idp-counters-pdf-decoder {
      description
        "Show the PDF decoder counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-pdf-decoder

    rpc get-idp-counters-http-decoder {
      description
        "Show the HTTP decoder counters";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-counters-http-decoder

    rpc get-idp-applications-information {
      description
        "Show IDP application statistics";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-applications-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-applications-information

    rpc get-idp-attack-table-information {
      description "Show IDP attack table";
      input {
        uses command-forwarding;

        choice lsys {
          case logical-system {
          }  // case logical-system
        }  // choice lsys
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-attack-table-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-attack-table-information

    rpc get-idp-attack-deprecated-list-information {
      description
        "Show IDP attack deprecated-list";
      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-attack-deprecated-list-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-attack-deprecated-list-information

    rpc get-idp-policy-deprecated-attack-information {
      description
        "Show IDP attack deprecated-list for the configured policy";
      input {
        leaf policy {
          type string;
          description "IDP policy name";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-policy-deprecated-attack-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-policy-deprecated-attack-information

    rpc get-idp-all-policy-deprecated-attack-information {
      description
        "Show IDP attack deprecated-list for all the idp policies in use";
      input {
        leaf logical-system {
          type string;
          description
            "Name of logical system";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-all-policy-deprecated-attack-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-all-policy-deprecated-attack-information

    rpc get-idp-attack-description-information {
      description
        "Show description of specified attack";
      input {
        leaf attack-name {
          type string;
          mandatory true;
          description "Attack name";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-attack-description-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-attack-description-information

    rpc get-idp-attack-detail-information {
      description
        "Show details of specified attack";
      input {
        leaf attack-name {
          type string;
          mandatory true;
          description "Attack name";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-attack-detail-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-attack-detail-information

    rpc get-idp-attack-group-entry-detail-information {
      description
        "Show detail of all attack and group";
      input {
        leaf offset {
          type union {
            type uint32;
            type string {
              pattern "<.*>|$.*";
            }
          }
          description
            "Offset value to start with (0 to any number)";
        }

        leaf limit {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type int32 {
              range "1 .. 50";
            }
          }
          description
            "Number of entries to display";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-attack-group-entry-detail-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-attack-group-entry-detail-information

    rpc get-idp-attack-group-entry-filters-information {
      description
        "Show detail of all attack and group which match the provided filters";
      input {
        leaf-list category {
          type string;
          ordered-by user;
          description "Category of attack";
        }

        leaf-list type-attack {
          type enumeration {
            enum "0" {
              value 0;
              description "Static attack";
            }
            enum "1" {
              value 1;
              description "Dynamic attack";
            }
          }
          ordered-by user;
          description "Type of attack";
        }

        leaf-list recommended-action {
          type enumeration {
            enum "0" {
              value 0;
              description "None";
            }
            enum "1" {
              value 1;
              description
                "Close client and server";
            }
            enum "2" {
              value 2;
              description "Close client";
            }
            enum "3" {
              value 3;
              description "Close server";
            }
            enum "4" {
              value 4;
              description "Ignore";
            }
            enum "5" {
              value 5;
              description "Drop";
            }
            enum "6" {
              value 6;
              description "Drop packet";
            }
          }
          ordered-by user;
          description "Recommended action";
        }

        leaf-list attack-type {
          type enumeration {
            enum "0" {
              value 0;
              description
                "Attack type - signature";
            }
            enum "1" {
              value 1;
              description
                "Attack type - anomaly";
            }
            enum "2" {
              value 2;
              description
                "Attack type - chain";
            }
          }
          ordered-by user;
          description "Attack type";
        }

        leaf-list performance {
          type enumeration {
            enum "0" {
              value 0;
              description
                "Performance 0 - unknown";
            }
            enum "1" {
              value 1;
              description
                "Performance 1 - low";
            }
            enum "5" {
              value 2;
              description
                "Performance 5 - medium ";
            }
            enum "9" {
              value 3;
              description
                "Performance 9 - high";
            }
          }
          ordered-by user;
          description
            "Performance category type";
        }

        leaf-list severity {
          type enumeration {
            enum "0" {
              value 0;
              description "Info attack";
            }
            enum "1" {
              value 1;
              description "Warning attack";
            }
            enum "2" {
              value 2;
              description "Minor attack";
            }
            enum "3" {
              value 3;
              description "Major attack";
            }
            enum "4" {
              value 4;
              description "Critical attack`";
            }
          }
          ordered-by user;
          description "Severity of attack";
        }

        leaf-list direction {
          type enumeration {
            enum "0" {
              value 0;
              description
                "Select attacks from client to server";
            }
            enum "1" {
              value 1;
              description
                "Select attacks from server to client";
            }
            enum "2" {
              value 2;
              description
                "Select attacks which can occur in either direction";
            }
          }
          ordered-by user;
          description "Direction of attack";
        }

        leaf-list recommended {
          type enumeration {
            enum "0" {
              value 0;
              description
                "Non recommended attack";
            }
            enum "1" {
              value 1;
              description
                "Recommended attack";
            }
          }
          ordered-by user;
          description
            "Recommended attack or not";
        }

        leaf-list group-name {
          type string;
          ordered-by user;
          description "Group name";
        }

        leaf-list group-type {
          type enumeration {
            enum "0" {
              value 0;
              description "Predefined group";
            }
            enum "1" {
              value 1;
              description "Custom attack";
            }
            enum "2" {
              value 2;
              description
                "Custom attack group";
            }
            enum "3" {
              value 3;
              description
                "Predefined attack";
            }
          }
          ordered-by user;
          description "Group type";
        }

        leaf-list service {
          type string;
          ordered-by user;
          description "Attack service type";
        }

        leaf-list cve-id {
          type string;
          ordered-by user;
          description "Cve identifier";
        }

        leaf-list certificate {
          type string;
          ordered-by user;
          description
            "Certificate identifier";
        }

        leaf-list bug-id {
          type string;
          ordered-by user;
          description "Bug identifier";
        }

        leaf-list false-positive {
          type enumeration {
            enum "0" {
              value 0;
              description
                "Falsepositive category - unknown";
            }
            enum "1" {
              value 1;
              description
                "Falsepositive category - occassionally";
            }
            enum "2" {
              value 2;
              description
                "Falsepositive category - frequently";
            }
            enum "3" {
              value 3;
              description
                "Falsepositive category - rarely";
            }
          }
          ordered-by user;
          description
            "Attack falsepositive type";
        }

        leaf limit {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type int32 {
              range "1 .. 50";
            }
          }
          description
            "Number of entries to display";
        }

        leaf offset {
          type union {
            type uint32;
            type string {
              pattern "<.*>|$.*";
            }
          }
          description
            "Offset to start with (0 to any number)";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-attack-group-entry-filters-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-attack-group-entry-filters-information

    rpc get-idp-group-attacklist-information {
      description
        "Shows list of all attacks present in the attack group specified";
      input {
        choice filter-choice {
          leaf predefined-group {
            type string;
            description
              "Predefined group name";
          }
          leaf custom-group {
            type string;
            description "Custom group name";
          }
          leaf dynamic-group {
            type string;
            description "Dynamic group name";
          }
          leaf policy {
            type string;
            description "IDP policy name";
          }
        }  // choice filter-choice

        leaf recursive {
          type empty;
          description
            "To show attack list recursively";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-group-attacklist-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-group-attacklist-information

    rpc get-idp-group-forattack-information {
      description
        "Shows list of predefined attack-groups to which the predefined-attack belongs";
      input {
        leaf attack-name {
          type string;
          mandatory true;
          description "Attack name";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml idp-group-forattack-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-idp-group-forattack-information

    rpc get-hakr-keychain-information {
      description
        "Show all protocols keychain";
      input {
        leaf verbosity {
          type enumeration {
            enum "brief" {
              value 0;
              description
                "Display brief output (default)";
            }
            enum "detail" {
              value 1;
              description
                "Display detailed output";
            }
          }
          default "brief";
        }
      }

      output {
        choice output_c {
          leaf output {
            type string;
          }
          anyxml hakr-keychain-information;
          anyxml multi-routing-engine-results;
        }  // choice output_c
      }
    }  // rpc get-hakr-keychain-information

    grouping command-forwarding {
      choice chassis-selector {
        leaf all-chassis {
          type empty;
          description "All chassis";
        }
        leaf all-lcc {
          type empty;
          description "All LCC chassis";
        }
        leaf scc {
          type empty;
          description "SCC";
        }
        leaf sfc {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type uint32;
          }
          description "SFC";
        }
        leaf lcc {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type uint32;
          }
          description "Specific LCC";
        }
        leaf node {
          type string;
          description "Specific node";
        }
        leaf bsys {
          type empty;
          description "Base system";
        }
        leaf gnf {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type uint32 {
              range "1 .. 10";
            }
          }
          description
            "Specific guest network function";
        }
        leaf all-gnfs {
          type empty;
          description
            "All guest network functions";
        }
        leaf all-system {
          type empty;
          description
            "All system (BSYS and GNFs)";
        }
        leaf server {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type uint32 {
              range "0 .. 1";
            }
          }
          description "Specific server slot";
        }
        leaf all-servers {
          type empty;
          description "All servers";
        }
        leaf vnf {
          type string;
          description
            "Specific virtual-network-function";
        }
        leaf all-vnfs {
          type empty;
          description
            "All virtual-network-functions";
        }
      }  // choice chassis-selector

      choice re-selector {
        leaf re0 {
          type empty;
          description "RE0";
        }
        leaf re1 {
          type empty;
          description "RE1";
        }
        leaf routing-engine {
          type enumeration {
            enum "local" {
              value 0;
              description
                "Local routing engine";
            }
            enum "other" {
              value 1;
              description
                "Other routing engine";
            }
            enum "master" {
              value 2;
              description
                "Master routing engine";
            }
            enum "backup" {
              value 3;
              description
                "Backup routing engine";
            }
            enum "both" {
              value 4;
              description
                "Both routing engines";
            }
          }
          description
            "Specific routing engine";
        }
      }  // choice re-selector

      choice lr-selector {
        leaf logical-system {
          type string;
          description
            "Name of logical system, or 'all'";
        }
      }  // choice lr-selector

      choice tenant-selector {
        leaf tenant {
          type string;
          description
            "Name of tenant, or 'all'";
        }
      }  // choice tenant-selector

      choice vc-selector {
        leaf local {
          type empty;
          description
            "Local virtual chassis member";
        }
        leaf all-members {
          type empty;
          description
            "All virtual chassis members";
        }
        leaf member {
          type union {
            type string {
              pattern "<.*>|$.*";
            }
            type uint32;
          }
          description
            "Specific virtual chassis member";
        }
      }  // choice vc-selector
    }  // grouping command-forwarding
  }  // module junos-rpc-security