module nokia-types-policy {

    yang-version 1.1;

    namespace
      "urn:nokia.com:sros:ns:yang:sr:types-policy";

    prefix types-policy;

    import nokia-sros-yang-extensions {
      prefix sros-ext;
    }

    organization "Nokia";

    contact
      "Nokia SR OS Support
         Web: <http://www.nokia.com>";

    description
      "Common policy data types used in the SR OS management system.

         Copyright 2016 Nokia. All rights reserved. Reproduction of this document
         is authorized on the condition that the foregoing copyright notice is included.

         This nokia-types-policy YANG module embodies Nokia's proprietary
         intellectual property. Nokia retains all title and ownership in the
         specification, including any revisions.

         Nokia grants all interested parties a non-exclusive license to use
         and distribute an unmodified copy of this specification in connection with
         management of Nokia products, and without fee, provided this
         copyright notice and license appear on all copies.

         This specification is supplied `as is', and Nokia makes no warranty,
         either express or implied, as to the use, operation, condition, or performance
         of the specification.";

    revision "2022-10-14";
    sros-ext:sros-major-release "rel22";

    typedef value-param-name {
      type union {
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
        type uint32 {
          range "0..4294967295";
        }
      }
      description
        "value   -        [0..4294967295]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef value-param-name-flex-algo {
      type union {
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
        type uint32 {
          range "128..255";
        }
      }
      description
        "value   -        [128..255]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef value-255-param-name {
      type union {
        type uint32 {
          range "0..255";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
      }
      description
        "value   -        [0..255]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef value-524287-param-name {
      type union {
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
        type uint32 {
          range "0..524287";
        }
      }
      description
        "value   -        [0..524287]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef value-param-name-metric {
      type union {
        type int64 {
          range "0..4294967295";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
      }
      description
        "value   -        [0..4294967295]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef value-param-name-metric-igp {
      type union {
        type enumeration {
          enum "igp" {
            value -1;
          }
        }
        type int64 {
          range "0..4294967295";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
      }
      description
        "value   -        [0..4294967295]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)
             igp";
    }

    typedef value-param-name-bgp-med-igp {
      type union {
        type enumeration {
          enum "igp" {
            value -3;
          }
          enum "min-igp" {
            value -2;
          }
        }
        type int64 {
          range "0..4294967295";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
      }
      description
        "value   -        [0..4294967295]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)
             min-igp
             igp";
    }

    typedef value-param-name-range {
      type union {
        type uint32 {
          range "1..4294967295";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
        type enumeration {
          enum "most-recent" {
            value -1;
          }
        }
      }
      description
        "value   -        [1..4294967295]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)
             most-recent ";
    }

    typedef repeat-value-param-name {
      type union {
        type int32 {
          range "1..50";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
      }
      description
        "value   -        [1..50]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef value-param-1024-name {
      type union {
        type uint32 {
          range "0..1024";
        }
        type string {
          length "1..32";
          pattern "@.+@" {
            error-message
              "String must start and end with an at-sign (@)";
          }
        }
      }
      description
        "A string containing the number in the range [0-1024] or
             a variable name.
             value   -        [0..1024]
             param-name     - [32 chars max] - Must start and end
                              with an at-sign (@)";
    }

    typedef policy-var-name {
      type string {
        length "1..32";
        pattern "@.+@" {
          error-message
            "String must start and end with an at-sign (@)";
        }
      }
    }

    typedef policy-qualifier {
      type enumeration {
        enum "equal" {
          value 1;
        }
        enum "or-higher" {
          value 2;
        }
        enum "or-lower" {
          value 3;
        }
      }
      default "equal";
      description "equal|or-higher|or-lower";
    }

    typedef param-midstring {
      type string {
        length "1..32";
        pattern ".*@.+@.*" {
          error-message
            "String must contain a parameter that starts and ends with an at-sign (@)";
        }
      }
      description
        "param-name     - [32 chars max] - Must contain a parameter that starts and ends
                              with an at-sign (@)";
    }

    typedef param-midstring-64 {
      type string {
        length "1..64";
        pattern ".*@.+@.*" {
          error-message
            "String must contain a parameter that starts and ends with an at-sign (@)";
        }
      }
      description
        "param-name     - [64 chars max] - Must contain a parameter that starts and ends
                              with an at-sign (@)";
    }
  }  // module nokia-types-policy