module opendaylight-group-types {
    namespace "urn:opendaylight:group:types";
    prefix group;

    import ietf-yang-types {prefix yang; revision-date "2013-07-15";}
    import opendaylight-action-types {prefix action;}
    import openflow-protocol { prefix ofproto; revision-date "2013-07-31"; }
    import openflow-types { prefix oft; revision-date "2013-07-31"; }

    revision "2013-10-18" {
        description "Initial revision of group service";
    }

    typedef group-id {
        type uint32;
    }

    typedef bucket-id {
        type uint32;
    }

    typedef group-types {
        type enumeration {
            enum group-all;
            enum group-select;
            enum group-indirect;
            enum group-ff;
        }
    }

    typedef group-capabilities {
        type enumeration {
            enum select-weight;
            enum select-liveness;
            enum chaining;
            enum chaining-checks;
        }
    }

    identity group-type {
        description "Base identity for all the available group types";
    }

    identity group-all {
        base group-type;
        description "All (multicast/broadcast) group";
    }

    identity group-select {
        base group-type;
        description "Select group";
    }

    identity group-indirect {
        base group-type;
        description "Indirect group";
    }

    identity group-ff {
        base group-type;
        description "Fast failover group";
    }

    identity group-capability {
        description "Base identity for all the supported group capabilities";
    }

    identity select-weight{
        base group-capability;
        description "Support weight for select groups";
    }

    identity select-liveness{
        base group-capability;
        description "Support liveness for select groups";
    }

    identity chaining{
        base group-capability;
        description "Support chaining groups";
    }

    identity chaining-checks{
        base group-capability;
        description "Check chaining for loops and delete";
    }

    typedef group-ref {
        type instance-identifier;
    }

    grouping group {

        leaf group-type {
            type group-types;
        }

        leaf group-id {
            type group-id;
        }

        leaf group-name {
            type string;
        }

        leaf container-name {
            type string;
        }

        leaf barrier {
            type boolean;
        }

        container buckets {
            list bucket {
                key "bucket-id";
                leaf bucket-id {
                    type bucket-id;
                }

                leaf weight {
                    type uint16;
                }

                leaf watch_port {
                    type uint32;
                }

                leaf watch_group {
                    type uint32;
                }

                uses action:action-list;
            }
        }
    }

    grouping group-statistics {

        leaf group-id {
            type group-id;
        }

        leaf ref-count {
            type yang:counter32;
        }

        leaf packet-count {
            type yang:counter64;
        }

        leaf byte-count {
            type yang:counter64;
        }

        container duration {
            leaf second {
                type yang:counter32;
            }
            leaf nanosecond {
                type yang:counter32;
            }
        }

        container buckets {
            list bucket-counter {
                key "bucket-id";
                leaf bucket-id {
                    type bucket-id;
                }

                leaf packet-count {
                    type yang:counter64;
                }

                leaf byte-count {
                    type yang:counter64;
                }
            }
        }
    }

    grouping group-features {

        leaf-list group-types-supported {
            type identityref {
                base group-type;
            }
        }

        leaf-list group-capabilities-supported {
            type identityref {
                base group-capability;
            }
        }

        leaf-list max-groups {
            type uint32;
            description "Maximum number of groups for each type";
            max-elements 4;
            ordered-by user;
        }

        leaf-list actions {
            type uint32;
            description "Bitmap number OFPAT_* that are supported";
            max-elements 4;
            ordered-by user;
        }
    }

    grouping group-statistics-request {
        list group-stats {
            key "group-id";
            leaf group-id {
                type group-id;
            }
        }
    }


    grouping group-statistics-reply {

        list group-stats {
            key "group-id";
            uses group-statistics;
        }
    }

    grouping group-desc-stats-reply {

        list group-desc-stats {
            key "group-id";
            uses group;
        }
    }

    grouping group-features-reply {
        uses group-features;
    }

    grouping groups {
        list group {
            key "group-id";

            uses group;
        }

        // BE-RECON: Modification for including stale-group for Reconciliation
        list stale-group {
            key "group-id";

            uses group;
        }
    }

    container group-message {
        uses group;
        uses ofproto:ofHeader;

        leaf command {
            type oft:group-mod-command;
        }
    }
}