module nokia-types-system {

    yang-version 1.1;

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

    prefix types-system;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import nokia-sros-yang-extensions {
      prefix sros-ext;
    }
    import nokia-types-sros {
      prefix types-sros;
    }

    organization "Nokia";

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

    description
      "Common system 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-system 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 "2023-05-24";
    sros-ext:sros-major-release "rel23";

    typedef device-state {
      type enumeration {
        enum "unknown" {
          value 1;
        }
        enum "not-equipped" {
          value 2;
        }
        enum "ok" {
          value 3;
        }
        enum "failed" {
          value 4;
        }
        enum "out-of-service" {
          value 5;
        }
        enum "not-provisioned" {
          value 6;
        }
        enum "not-applicable" {
          value 7;
        }
      }
      description
        "Values used to identify states of chassis
             components such as fans and power supplies.";
    }

    typedef action-result {
      type enumeration {
        enum "none" {
          value 1;
        }
        enum "in-progress" {
          value 2;
        }
        enum "success" {
          value 3;
        }
        enum "failed" {
          value 4;
        }
      }
      description
        "Values used to identify the result of the action.";
    }

    typedef action-result-with-interrupted {
      type enumeration {
        enum "none" {
          value 1;
        }
        enum "in-progress" {
          value 2;
        }
        enum "success" {
          value 3;
        }
        enum "failed" {
          value 4;
        }
        enum "interrupted" {
          value 5;
        }
      }
      description
        "Values used to identify the result of the action including interrupted value.";
    }

    typedef script-state {
      type enumeration {
        enum "not-run" {
          value 0;
        }
        enum "success" {
          value 1;
        }
        enum "fail" {
          value 2;
        }
      }
      description
        "Values used to identify the script status.";
    }

    typedef led-state {
      type enumeration {
        enum "not-applicable" {
          value 0;
        }
        enum "off" {
          value 1;
        }
        enum "red" {
          value 2;
        }
        enum "amber" {
          value 3;
        }
        enum "yellow" {
          value 4;
        }
        enum "green" {
          value 5;
        }
        enum "amber-blink" {
          value 6;
        }
        enum "yellow-blink" {
          value 7;
        }
        enum "green-blink" {
          value 8;
        }
        enum "red-blink" {
          value 9;
        }
      }
      description
        "Values used to identify state LEDs on Nokia SROS series cards.";
    }

    typedef week {
      type enumeration {
        enum "first" {
          value 0;
        }
        enum "second" {
          value 1;
        }
        enum "third" {
          value 2;
        }
        enum "fourth" {
          value 3;
        }
        enum "last" {
          value 4;
        }
      }
      description "The week of the month.";
    }

    typedef day-of-week-name-long {
      type enumeration {
        enum "sunday" {
          value 0;
        }
        enum "monday" {
          value 1;
        }
        enum "tuesday" {
          value 2;
        }
        enum "wednesday" {
          value 3;
        }
        enum "thursday" {
          value 4;
        }
        enum "friday" {
          value 5;
        }
        enum "saturday" {
          value 6;
        }
      }
      description "The day of the week.";
    }

    typedef month-name-long {
      type enumeration {
        enum "january" {
          value 0;
        }
        enum "february" {
          value 1;
        }
        enum "march" {
          value 2;
        }
        enum "april" {
          value 3;
        }
        enum "may" {
          value 4;
        }
        enum "june" {
          value 5;
        }
        enum "july" {
          value 6;
        }
        enum "august" {
          value 7;
        }
        enum "september" {
          value 8;
        }
        enum "october" {
          value 9;
        }
        enum "november" {
          value 10;
        }
        enum "december" {
          value 11;
        }
      }
      description "The month of the year.";
    }

    typedef cir-rate {
      type union {
        type int32 {
          range "0..100000000";
        }
        type enumeration {
          enum "max" {
            value -1;
          }
        }
      }
      description
        "The CIR rate to be used in kbps.";
    }

    typedef pir-rate {
      type union {
        type int32 {
          range "1..100000000";
        }
        type enumeration {
          enum "max" {
            value -1;
          }
        }
      }
      description
        "The PIR rate to be used in kbps.";
    }

    typedef oper-pir-rate {
      type union {
        type int32 {
          range "0..100000000";
        }
        type enumeration {
          enum "max" {
            value -1;
          }
        }
      }
      description
        "Operational PIR rate in kbps.";
    }

    typedef dist-cpu-protocol-id {
      type enumeration {
        enum "arp" {
          value 1;
        }
        enum "dhcp" {
          value 2;
        }
        enum "http-redirect" {
          value 3;
        }
        enum "icmp" {
          value 4;
        }
        enum "igmp" {
          value 5;
        }
        enum "mld" {
          value 6;
        }
        enum "ndis" {
          value 7;
        }
        enum "pppoe-pppoa" {
          value 8;
        }
        enum "all-unspecified" {
          value 9;
        }
        enum "mpls-ttl" {
          value 10;
        }
        enum "bfd-cpm" {
          value 11;
        }
        enum "bgp" {
          value 12;
        }
        enum "eth-cfm" {
          value 13;
        }
        enum "isis" {
          value 14;
        }
        enum "ldp" {
          value 15;
        }
        enum "ospf" {
          value 16;
        }
        enum "pim" {
          value 17;
        }
        enum "rsvp" {
          value 18;
        }
        enum "icmp-ping-check" {
          value 19;
        }
        enum "lacp" {
          value 21;
        }
        enum "vrrp" {
          value 22;
        }
        enum "multi-chassis" {
          value 23;
        }
        enum "multi-chassis-sync" {
          value 24;
        }
        enum "bfd" {
          value 25;
        }
        enum "ftp" {
          value 26;
        }
        enum "icmp-v4" {
          value 27;
        }
        enum "icmp-v6" {
          value 28;
        }
        enum "l3-to-my-ipv4" {
          value 29;
        }
        enum "l3-to-my-ipv6" {
          value 30;
        }
        enum "lsp-ping" {
          value 31;
        }
        enum "mc-lag" {
          value 32;
        }
        enum "mcast-snooping" {
          value 33;
        }
        enum "radius" {
          value 34;
        }
        enum "rip" {
          value 35;
        }
        enum "sbfd-reflector" {
          value 36;
        }
        enum "snmp" {
          value 37;
        }
        enum "ssh" {
          value 38;
        }
        enum "stp" {
          value 39;
        }
        enum "tacacs" {
          value 40;
        }
        enum "telnet" {
          value 41;
        }
        enum "tftp" {
          value 42;
        }
        enum "twamp" {
          value 43;
        }
      }
      description
        "Indicates the protocols supported for the distributed CPU
             protection policy.";
    }

    typedef server-oper-status {
      type enumeration {
        enum "up" {
          value 1;
        }
        enum "down" {
          value 2;
        }
      }
      description
        "Operational status of server.";
    }

    typedef application {
      type enumeration {
        enum "telnet" {
          value 1;
        }
        enum "ftp" {
          value 2;
        }
        enum "ssh" {
          value 3;
        }
        enum "radius" {
          value 4;
        }
        enum "tacplus" {
          value 5;
        }
        enum "snmptrap" {
          value 6;
        }
        enum "syslog" {
          value 7;
        }
        enum "icmp-ping" {
          value 8;
        }
        enum "traceroute" {
          value 9;
        }
        enum "dns" {
          value 10;
        }
        enum "sntp" {
          value 11;
        }
        enum "ntp" {
          value 12;
        }
        enum "cflowd" {
          value 13;
        }
        enum "telnet6" {
          value 14;
        }
        enum "ftp6" {
          value 15;
        }
        enum "radius6" {
          value 16;
        }
        enum "tacplus6" {
          value 17;
        }
        enum "snmptrap6" {
          value 18;
        }
        enum "syslog6" {
          value 19;
        }
        enum "icmp-ping6" {
          value 20;
        }
        enum "traceroute6" {
          value 21;
        }
        enum "dns6" {
          value 22;
        }
        enum "ptp" {
          value 23;
        }
        enum "mcreporter" {
          value 24;
        }
        enum "cflowd6" {
          value 25;
        }
        enum "ntp6" {
          value 26;
        }
        enum "sflow" {
          value 27;
        }
        enum "sflow6" {
          value 28;
        }
        enum "icmp-error" {
          value 29;
        }
        enum "icmp-error6" {
          value 30;
        }
        enum "ldap" {
          value 31;
        }
        enum "ldap6" {
          value 32;
        }
        enum "ssh6" {
          value 33;
        }
        enum "ptp6" {
          value 34;
        }
      }
      description "Application type.";
    }

    typedef dcp-exceed-action {
      type enumeration {
        enum "discard" {
          value 1;
        }
        enum "low-priority" {
          value 2;
        }
        enum "none" {
          value 3;
        }
      }
      default "none";
    }

    typedef session-limit {
      type int32 {
        range "0..50";
      }
      description
        "Session-limit is an integer value that specifies the limit
             for number of concurrent user access sessions (SSH, Telnet, Total).";
    }

    typedef session-type {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "telnet" {
          value 1;
        }
        enum "telnet6" {
          value 2;
        }
        enum "console" {
          value 3;
        }
        enum "bluetooth" {
          value 4;
        }
        enum "ssh" {
          value 5;
        }
        enum "sshv2" {
          value 6;
        }
        enum "netconf" {
          value 7;
        }
        enum "ftp" {
          value 8;
        }
        enum "grpc" {
          value 9;
        }
        enum "cron-ehs" {
          value 10;
        }
      }
      description "Type of session";
    }

    typedef permit-deny {
      type enumeration {
        enum "permit" {
          value 1;
        }
        enum "deny" {
          value 2;
        }
      }
      default "permit";
    }

    typedef peq-type {
      type enumeration {
        enum "apeq-dc-2000" {
          value 2;
        }
        enum "apeq-dc-2200-2800" {
          value 3;
        }
        enum "apeq-ac-3000" {
          value 4;
        }
        enum "apeq-hvdc-3000" {
          value 5;
        }
        enum "apeq-dc-4275" {
          value 10;
        }
        enum "ixr-ac-hvdc-3000" {
          value 11;
        }
        enum "ixr-dc-3000" {
          value 12;
        }
        enum "apeq-ac-4400" {
          value 13;
        }
      }
    }

    typedef peq-type-state {
      type enumeration {
        enum "unassigned" {
          value 1;
        }
        enum "apeq-dc-2000" {
          value 2;
        }
        enum "apeq-dc-2200-2800" {
          value 3;
        }
        enum "apeq-ac-3000" {
          value 4;
        }
        enum "apeq-hvdc-3000" {
          value 5;
        }
        enum "apeq-dc-4275" {
          value 10;
        }
        enum "ixr-ac-hvdc-3000" {
          value 11;
        }
        enum "ixr-dc-3000" {
          value 12;
        }
        enum "apeq-ac-4400" {
          value 13;
        }
      }
    }

    typedef ssm-quality-level-override {
      type enumeration {
        enum "unused" {
          value 0;
        }
        enum "prs" {
          value 1;
        }
        enum "stu" {
          value 2;
        }
        enum "st2" {
          value 3;
        }
        enum "tnc" {
          value 4;
        }
        enum "st3e" {
          value 5;
        }
        enum "st3" {
          value 6;
        }
        enum "prc" {
          value 10;
        }
        enum "ssua" {
          value 11;
        }
        enum "ssub" {
          value 12;
        }
        enum "sec" {
          value 13;
        }
      }
      description
        "ssm-quality-level-override is an enumerated integer that describes the values used
             to identify the SSM Quality level used to override the one extracted from received
             SSM messages.";
    }

    typedef ref-ssm-quality-level-override {
      type enumeration {
        enum "unused" {
          value 0;
        }
        enum "prs" {
          value 1;
        }
        enum "stu" {
          value 2;
        }
        enum "st2" {
          value 3;
        }
        enum "tnc" {
          value 4;
        }
        enum "st3e" {
          value 5;
        }
        enum "st3" {
          value 6;
        }
        enum "prc" {
          value 10;
        }
        enum "ssua" {
          value 11;
        }
        enum "ssub" {
          value 12;
        }
        enum "sec" {
          value 13;
        }
        enum "eec1" {
          value 17;
        }
        enum "eec2" {
          value 18;
        }
      }
      description
        "ssm-quality-level-override is an enumerated integer that describes the values used
             to identify the SSM Quality level used to override the one extracted from received
             SSM messages.";
    }

    typedef gnss-ssm-quality-level-override {
      type enumeration {
        enum "unused" {
          value 0;
        }
        enum "prs" {
          value 1;
        }
        enum "stu" {
          value 2;
        }
        enum "st2" {
          value 3;
        }
        enum "tnc" {
          value 4;
        }
        enum "st3e" {
          value 5;
        }
        enum "st3" {
          value 6;
        }
      }
      description
        "gnss-ssm-quality-level-override is an enumerated integer that describes the values used
             to override the quality level provided by a GNSS port.";
    }

    typedef sets-ref-source {
      type enumeration {
        enum "ref1" {
          value 1;
        }
        enum "ref2" {
          value 2;
        }
        enum "bits" {
          value 3;
        }
        enum "ptp" {
          value 5;
        }
        enum "none" {
          value 6;
        }
        enum "synce" {
          value 7;
        }
        enum "gnss" {
          value 9;
        }
      }
      description
        "The sets-ref-source data type is an enumerated integer that
             describes the values used to identify the Synchronous Equipment
             Timing Source (SETS) timing reference source.";
    }

    typedef bits-out-source {
      type enumeration {
        enum "line-ref" {
          value 1;
        }
        enum "internal-clock" {
          value 2;
        }
      }
      description
        "The bits-out-source is an enumerated integer that describes the
             values used to identity the source of the BITS (Building Integrated
             Timing Supply) output.

             When bits-out-source is 'lineRef (1)', the BITS output timing is
             selected from either the one of the timing input references, without
             any filtering.  Either the first or second line reference, or the PTP
             timing input reference may be selected to be transmitted in this
             manner.  The BITS timing input is never selected in this mode.

             When bits-out-source is 'internalClock (2)', the BITS output timing
             is driven from the system timing.";
    }

    typedef bits-if-type {
      type enumeration {
        enum "ds1-esf" {
          value 1;
        }
        enum "ds1-sf" {
          value 2;
        }
        enum "e1-pcm30crc" {
          value 3;
        }
        enum "e1-pcm31crc" {
          value 4;
        }
        enum "g703-2048khz" {
          value 5;
        }
      }
      description
        "The bits-if-type data type is an enumerated integer that describes
             the values used to identify the interface and framing types of a BITS
             (Building Integrated Timing Supply) interface.";
    }

    typedef cpm-flash-id {
      type enumeration {
        enum "cf1" {
          value 1;
        }
        enum "cf2" {
          value 2;
        }
        enum "cf3" {
          value 3;
        }
      }
      description
        "Values used to identify a CPM flash card.";
    }

    typedef running-finished {
      type enumeration {
        enum "running" {
          value 0;
        }
        enum "finished" {
          value 1;
        }
      }
      description
        "Values used to identify the status of a job.";
    }

    typedef hours-minutes-twenty-four {
      type string {
        length "5";
        pattern
          "([0-1][0-9]|2[0-3]):[0-5][0-9]" {
          error-message
            "The time format is [hh:mm]. The range of hours is '00' to '23'. The range of minutes is '00' to '59'.";
        }
      }
      description
        "Hours and minutes in 24 hour format. Hours and minutes are zero padded to two digits each if necessary.";
    }

    typedef hours-minutes-with-range {
      type string {
        length "5..6";
        pattern
          "-00:(([1-5][0-9])|(0[1-9]|[0-5][1-9]))|12:00|(-1[0-1]|-0[1-9]|1[0-1]|0[0-9]):[0-5][0-9]" {
          error-message
            "The time format is: [hh:mm]. The range of hours is '-11' to '12'. The range of minutes is '00' to '59'. If the hours is '12', the minutes must be '00'.";
        }
      }
      description
        "Positive or negative time offset. Hours and minutes are zero padded to two digits each if necessary.";
    }

    typedef cli-engine-type {
      type enumeration {
        enum "classic-cli" {
          value 1;
        }
        enum "md-cli" {
          value 2;
        }
      }
      default "md-cli";
      description
        "Name identifying the CLI engine.";
    }

    typedef threshold-event-type {
      type enumeration {
        enum "none" {
          value 1;
        }
        enum "log" {
          value 2;
        }
        enum "trap" {
          value 3;
        }
        enum "both" {
          value 4;
        }
      }
      default "both";
      description
        "Describes threshold event types";
    }

    typedef threshold-startup-alarm {
      type enumeration {
        enum "rising" {
          value 1;
        }
        enum "falling" {
          value 2;
        }
        enum "either" {
          value 3;
        }
      }
      default "either";
      description
        "Describes threshold startup alarm types";
    }

    typedef threshold-sample {
      type enumeration {
        enum "absolute" {
          value 1;
        }
        enum "delta" {
          value 2;
        }
      }
      default "absolute";
      description
        "Describes threshold sample types.";
    }

    typedef threshold-rmon-event-type {
      type enumeration {
        enum "none" {
          value 1;
        }
        enum "log" {
          value 2;
        }
        enum "trap" {
          value 3;
        }
        enum "both" {
          value 4;
        }
      }
      default "both";
      description
        "Describes threshold rmon event types";
    }

    typedef user-session-id {
      type uint32 {
        range "1..max";
      }
      description
        "User session unique identifier.";
    }

    typedef cron-oper-state {
      type enumeration {
        enum "enabled" {
          value 1;
        }
        enum "disabled" {
          value 2;
        }
        enum "finished" {
          value 3;
        }
      }
      description
        "Actual status of the script-policy in the runtime system";
    }

    typedef schedule-failure {
      type enumeration {
        enum "no-response" {
          value -1;
        }
        enum "no-error" {
          value 0;
        }
        enum "too-big" {
          value 1;
        }
        enum "no-such-name" {
          value 2;
        }
        enum "bad-value" {
          value 3;
        }
        enum "read-only" {
          value 4;
        }
        enum "general-error" {
          value 5;
        }
        enum "no-access" {
          value 6;
        }
        enum "wrong-type" {
          value 7;
        }
        enum "wrong-length" {
          value 8;
        }
        enum "wrong-encoding" {
          value 9;
        }
        enum "wrong-value" {
          value 10;
        }
        enum "no-creation" {
          value 11;
        }
        enum "inconsistent-value" {
          value 12;
        }
        enum "resource-unavailable" {
          value 13;
        }
        enum "commit-failed" {
          value 14;
        }
        enum "undo-failed" {
          value 15;
        }
        enum "authorization-error" {
          value 16;
        }
        enum "not-writable" {
          value 17;
        }
        enum "inconsistent-name" {
          value 18;
        }
      }
      description
        "Last schedule failure causes";
    }

    typedef script-auth-application {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "cron" {
          value 1;
        }
        enum "xmpp" {
          value 2;
        }
        enum "event-script" {
          value 3;
        }
        enum "vsd" {
          value 4;
        }
        enum "cron-python" {
          value 5;
        }
        enum "event-script-python" {
          value 6;
        }
      }
      description
        "Indicates the module that started this run of a script";
    }

    typedef run-state {
      type enumeration {
        enum "initializing" {
          value 1;
        }
        enum "executing" {
          value 2;
        }
        enum "suspending" {
          value 3;
        }
        enum "suspended" {
          value 4;
        }
        enum "resuming" {
          value 5;
        }
        enum "aborting" {
          value 6;
        }
        enum "terminated" {
          value 7;
        }
      }
      description "Script's execution state";
    }

    typedef run-exit-code {
      type enumeration {
        enum "no-error" {
          value 1;
        }
        enum "halted" {
          value 2;
        }
        enum "life-time-exceeded" {
          value 3;
        }
        enum "no-resources-left" {
          value 4;
        }
        enum "language-error" {
          value 5;
        }
        enum "runtime-error" {
          value 6;
        }
        enum "invalid-argument" {
          value 7;
        }
        enum "security-violation" {
          value 8;
        }
        enum "generic-error" {
          value 9;
        }
      }
      description
        "Reason why a script finished execution";
    }

    typedef script-oper-state {
      type enumeration {
        enum "enabled" {
          value 1;
        }
        enum "disabled" {
          value 2;
        }
        enum "editing" {
          value 3;
        }
        enum "retrieving" {
          value 4;
        }
        enum "compiling" {
          value 5;
        }
        enum "no-such-script" {
          value 6;
        }
        enum "access-denied" {
          value 7;
        }
        enum "wrong-language" {
          value 8;
        }
        enum "wrong-version" {
          value 9;
        }
        enum "compilation-failed" {
          value 10;
        }
        enum "no-resources-left" {
          value 11;
        }
        enum "unknown-protocol" {
          value 12;
        }
        enum "protocol-failure" {
          value 13;
        }
        enum "generic-error" {
          value 14;
        }
      }
      description
        "Actual status of the script in the runtime system";
    }

    typedef script-policy-oper-state {
      type enumeration {
        enum "enabled" {
          value 1;
        }
        enum "disabled" {
          value 2;
        }
        enum "expired" {
          value 3;
        }
      }
      description
        "Actual status of the script-policy in the runtime system";
    }

    typedef engine-id-as-string {
      type string {
        length "10..64";
        pattern "[0-9a-f]*";
      }
      description
        "Describes snmp engine id in the string format";
    }

    typedef telemetry-value-encoding {
      type enumeration {
        enum "json" {
          value 0;
          description "JSON encoded text";
        }
        enum "bytes" {
          value 1;
          description
            "Encoded according to gnmi.schemas";
        }
        enum "proto" {
          value 2;
          description
            "Encoded with scalar TypedValue values";
        }
        enum "json-ietf" {
          value 4;
          description
            "JSON encoded text as per RFC 7951";
        }
      }
      description
        "The encoding of data notifications.

             If gNMI version is configured to 0.7.0,
             enum 'bytes' and 'proto' are swapped.";
    }

    typedef telemetry-path-mode {
      type enumeration {
        enum "target-defined" {
          value 0;
        }
        enum "on-change" {
          value 1;
        }
        enum "sample" {
          value 2;
        }
      }
      description
        "Subscription path mode, indicating how the
             SROS must return values in a subscription.

             Value 'target-defined' indicates that the SROS
             selects the relevant mode for each leaf.

             Value 'on-change' indicates that the SROS sends
             an update on leaf value change.

             Value 'sample' indicates that the SROS samples
             values according to the interval.";
    }

    typedef hash-polynomial-type {
      type enumeration {
        enum "poly1" {
          value 1;
        }
        enum "poly2" {
          value 2;
        }
        enum "poly3" {
          value 3;
        }
        enum "poly4" {
          value 4;
        }
        enum "poly5" {
          value 5;
        }
        enum "poly6" {
          value 6;
        }
      }
      description
        "CRC Polynomial options used in load balancing algorithm
             for distribution of packets under ECMP and LAG.";
    }

    typedef remote-mgmt-registration-status {
      type enumeration {
        enum "unknown" {
          value 0;
        }
        enum "succeeded" {
          value 1;
        }
        enum "cancelled" {
          value 2;
        }
        enum "unreachable" {
          value 3;
        }
        enum "refused" {
          value 4;
        }
        enum "dns-resolution-failed" {
          value 5;
        }
        enum "out-of-resources" {
          value 6;
        }
        enum "internal" {
          value 100;
        }
      }
      description
        "Status of device remote registration attemt.";
    }

    typedef remote-mgmt-registration-port {
      type union {
        type types-sros:tcp-udp-port-non-zero;
        type enumeration {
          enum "grpc-default" {
            value -1;
          }
        }
      }
      description "Source port type.";
    }

    typedef schema-path-state-type {
      type union {
        type types-sros:url;
        type enumeration {
          enum "error-connection" {
            value 0;
          }
          enum "error-too-long" {
            value 1;
          }
          enum "error-invalid" {
            value 2;
          }
        }
      }
      description "Value of schema path.";
    }

    typedef dcpu-policy-type {
      type enumeration {
        enum "access-network" {
          value 1;
        }
        enum "port" {
          value 2;
        }
      }
      description
        "Distributed CPU protection policy type";
    }

    typedef ntp-refid {
      type union {
        type inet:ipv4-address;
        type uint32;
        type string {
          length "0..4";
        }
      }
      description
        "A code identifying the particular server or reference
             clock.  The interpretation depends upon stratum.  It
             could be an IPv4 address, the first 32 bits of the MD5 hash
             of the IPv6 address, or a string for the Reference Identifier
             and kiss codes.

             Some examples:

             -- a refclock ID like '127.127.1.0' for local clock sync

             -- uni/multi/broadcast associations for IPv4 will look like
               '203.0.113.1' and '0x4321FEDC' for IPv6

             -- sync with a primary source will look like 'DCN', 'NIST', 'ATOM'

             -- kiss codes will look like 'AUTH', 'DROP', or 'RATE'

             Note that the use of an MD5 hash for IPv6 addresses is not
             for cryptographic purposes.";
    }

    typedef ntp-stratum {
      type uint8;
      description
        "Indicates the level of the server in the NTP hierarchy. As
             stratum number increases, the accuracy is degraded.  Primary
             servers are stratum while a maximum value of 16 indicates
             unsynchronized.  The values have the following specific
             semantics:
             | 0      | unspecified or invalid
             | 1      | primary server (e.g., equipped with a GPS receiver)
             | 2-15   | secondary server (via NTP)
             | 16     | unsynchronized
             | 17-255 | reserved";
    }

    typedef ntp-date-and-time {
      type union {
        type yang:date-and-time;
        type uint8;
      }
      description
        "Follows the date-and-time format when valid values exist.
             Otherwise, allows for setting a special value such as zero.";
    }

    typedef log2seconds {
      type int8;
      description
        "An 8-bit signed integer that represents signed log2 seconds.";
    }

    typedef http-version-type {
      type enumeration {
        enum "1.0" {
          value 1;
        }
        enum "1.1" {
          value 2;
        }
      }
      default "1.1";
      description "HTTP version type";
    }

    typedef ixr-resource-index-owner {
      type enumeration {
        enum "bgp" {
          value 1;
        }
        enum "rsvp" {
          value 2;
        }
        enum "ldp" {
          value 3;
        }
        enum "sr-mpls" {
          value 4;
        }
        enum "service-sdp-bind-gre" {
          value 5;
        }
        enum "service" {
          value 9;
        }
        enum "service-sap" {
          value 10;
        }
        enum "service-sdp-bind" {
          value 11;
        }
        enum "service-evpn" {
          value 12;
        }
        enum "interface" {
          value 13;
        }
        enum "arp" {
          value 14;
        }
        enum "ipv6" {
          value 15;
        }
        enum "rtm" {
          value 16;
        }
        enum "ptp" {
          value 17;
        }
        enum "bfd" {
          value 18;
        }
        enum "port" {
          value 19;
        }
        enum "eth-cfm" {
          value 20;
        }
        enum "tree-sid" {
          value 21;
        }
        enum "service-sdp-gre" {
          value 22;
        }
        enum "port-lag-vlan-qos" {
          value 23;
        }
        enum "srv6" {
          value 24;
        }
      }
      description "IXR resource owners.";
    }
  }  // module nokia-types-system