module clixon-example {
    yang-version 1.1;
    namespace "urn:example:clixon";
    prefix ex;
    import clixon-autocli{
        prefix autocli;
    }
    description
        "Clixon example used as a part of the Clixon test suite.
         It can be used as a basis for making new Clixon applications.
         Note, may change without updating revision, just for testing current master.
         ";
    revision 2022-11-01 {
        description "Removing dependency on standard IETF models";
    }
    revision 2020-12-01 {
        description "Added table/parameter/value as the primary data example";
    }
    revision 2020-03-11 {
        description "Added container around translation list. Released in Clixon 4.4.0";
    }
    revision 2019-11-05 {
        description "Augment interface. Released in Clixon 4.3.0";
    }
    revision 2019-07-23 {
        description "Extension e4. Released in Clixon 4.1.0";
    }
    revision 2019-01-13 {
        description "Released in Clixon 3.9";
    }
    /* Generic config data */
    container table{
        list parameter{
            key name;
            leaf name{
                type string;
            }
            leaf value{
                type string;
            }
            leaf hidden{
                type string;
                autocli:hide;
            }
            leaf stat{
                description "Inline state data for example application";
                config false;
                type int32;
            }
        }
    }
    /* State data (not config) for the example application*/
    container state {
        config false;
        description "state data for the example application (must be here for example get operation)";
        leaf-list op {
            type string;
        }
    }
    /* yang extension implemented by the example backend code. */
    extension e4 {
        description
            "The first child of the ex:e4 (unknown) statement is inserted into 
            the module as a regular data statement. This means that 'uses bar;'
            in the ex:e4 statement below is a valid data node";
        argument arg;
    }
    grouping bar {
        leaf bar{
            type string;
        }
    }
    ex:e4 arg1{
        uses bar;
    }
    /* Example notification as used in RFC 5277 and RFC 8040 */
    notification event {
        description "Example notification event.";
        leaf event-class {
            type string;
            description "Event class identifier.";
        }
        container reportingEntity {
            description "Event specific information.";
            leaf card {
                type string;
                description "Line card identifier.";
            }
        }
        leaf severity {
            type string;
            description "Event severity description.";
        }
    }
    rpc client-rpc {
        description "Example local client-side RPC that is processed by the
                     the netconf/restconf and not sent to the backend.
                     This is a clixon implementation detail: some rpc:s
                     are better processed by the client for API or perf reasons";
        input {
            leaf x {
                type string;
            }
        }
        output {
            leaf x {
                type string;
            }
        }
    }
    rpc empty {
        description "Smallest possible RPC with no input or output sections";
    }
    rpc optional {
        description "Small RPC with optional input and output";
        input {
            leaf x {
                type string;
            }
        }
        output {
            leaf x {
                type string;
            }
        }
    }
    rpc example {
        description "Some example input/output for testing RFC7950 7.14.
                     RPC simply echoes the input for debugging.";
        input {
            leaf x {
                description
                    "If a leaf in the input tree has a 'mandatory' statement with
                   the value 'true', the leaf MUST be present in an RPC invocation.";
                type string;
                mandatory true;
            }
            leaf y {
                description
                    "If a leaf in the input tree has a 'mandatory' statement with the
                  value 'true', the leaf MUST be present in an RPC invocation.";
                type string;
                default "42";
            }
            leaf-list z {
                description
                    "If a leaf-list in the input tree has one or more default 
                     values, the server MUST use these values (XXX not supported)";
                type string;
            }
            leaf w {
                description
                    "If any node has a 'when' statement that would evaluate to 
                    'false',then this node MUST NOT be present in the input tree.
                     (XXX not supported)";
                type string;
            }
            list u0 {
                description "list without key";
                leaf uk{
                    type string;
                }
            }
            list u1 {
                description "list with key";
                key uk;
                leaf uk{
                    type string;
                }
                leaf val{
                    type string;
                }
            }
        }
        output {
            leaf x {
                type string;
            }
            leaf y {
                type string;
            }
            leaf z {
                type string;
            }
            leaf w {
                type string;
            }
            list u0 {
                leaf uk{
                    type string;
                }
            } 
            list u1 {
                key uk;
                leaf uk{
                    type string;
                }
                leaf val{
                    type string;
                }
            }
        }
    }
}
