module odl-pcep-message {
    yang-version 1;
    namespace "urn:opendaylight:params:xml:ns:yang:pcep:message";
    prefix "pcep-msg";

    import odl-pcep-types { prefix pcep-types; revision-date 2025-09-30; }
    import odl-pcep-object { prefix pcep-object; revision-date 2025-09-30; }

    organization "Cisco Systems, Inc.";
    contact "Robert Varga <rovarga@cisco.com>";

    description
        "This module contains the base data model of PCEP Messages defined in:
            - RFC5440: Stateless
            - RFC5886: Monitoring Tools
            - RFC8231: Stateful
            - RFC8253: TLS
            - RFC8281: Initiated

        Copyright (c)2013 Cisco Systems, Inc. All rights reserved.
        Copyright (c)2025 Orange. All rights reserved.

        This program and the accompanying materials are made available
        under the terms of the Eclipse Public License v1.0 which
        accompanies this distribution, and is available at
        http://www.eclipse.org/legal/epl-v10.html";

    revision "2025-09-30" {
        description "Split old pcep-types into odl-pcep-types, odl-pcep-object and
                     odl-pcep-message following the redesign of pcep yang models.
                     This is the Message part.";
    }

    revision "2018-11-09" {
        description
            "P2MP extension.";
        reference "RFC8306";
    }

    revision "2013-10-07" {
        description
            "Initial revision.";
    }

    // Common Message Definitions

    grouping message {
        description "Marker grouping for message groupings.";
    }

    grouping message-header {
        description "Common Header";
        reference "https://tools.ietf.org/html/rfc5440#section-6.1";

        leaf version {
            type pcep-types:protocol-version;
            default 1;
        }
    }

    grouping open-message {
        uses message;

        container open-message {
            description "Open Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.2";

            uses message-header;

            uses pcep-object:open-object;
        }
    }

    grouping keepalive-message {
        uses message;

        container keepalive-message {
            description "Keepalive Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.3";

            uses message-header;
        }
    }

    grouping pcntf-message {
        uses message;

        container pcntf-message {
            description "Notification Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.6";

            uses message-header;

            list notifications {
                list rps {
                    uses pcep-object:rp-object;
                }

                list notifications {
                    uses pcep-object:notification-object;
                }
            }
        }
    }

    grouping pcerr-message {
        uses message;

        container pcerr-message {
            description "Error Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.7";

            uses message-header;

            list errors {
                uses pcep-object:pcep-error-object;
            }

            choice error-type {
                case request-case {
                    container request {
                        list rps {
                            uses pcep-object:rp-object;
                        }
                    }
                }
                case stateful-case {
                    container stateful {
                        list srps {
                            uses pcep-object:srp-object;
                        }
                    }
                }
                case session-case {
                    container session {
                        uses pcep-object:open-object;
                    }
                }
            }
        }
    }

    grouping close-message {
        uses message;

        container c-close-message {
            description "Close Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.8";

            uses message-header;

            uses pcep-object:close-object;
        }
    }

    grouping start-tls-message {
        uses message;

        container start-tls-message {
            description "StartTLS Message";
            reference "https://tools.ietf.org/html/rfc8253#section-3.3";

            uses message-header;
        }
    }

    // Stateless Messages

    grouping pcreq-message {
        uses message;

        container pcreq-message {
            description "Path Computation Request Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.4";

            uses message-header;

            list requests {
                uses pcep-object:rp-object;

                container path-key-expansion {
                    when "rp/path-key = true";
                    uses pcep-object:path-key-object;
                }

                container segment-computation {
                    when "rp/path-key = false";

                    container p2p {
                        when "../rp/p2mp = false";
                        uses pcep-object:p2p;
                    }

                    container p2mp {
                        reference "https://tools.ietf.org/html/rfc8306#section-3.4";
                        when "../rp/p2mp = true";

                        uses pcep-object:p2mp;
                    }
                }

                uses pcep-object:vendor-information-objects;
            }

            list svec {
                uses pcep-object:svec;
            }

            container monitoring-request {
                uses pcep-object:monitoring;

                list pce-id-list {
                    uses pcep-object:pce-id-object;
                }
            }
        }
    }

    grouping pcmonrep-message {
        description "The PCMonRep message is used to provide PCE
        state metrics back to the requester for out-of-band monitoring requests.";
        reference "https://tools.ietf.org/html/rfc5886#section-9.2";

        uses message;
        container pcmonrep-message {
            uses pcep-object:monitoring-response;
        }
    }

    grouping pcrep-message {
        uses message;

        container pcrep-message {
            description "Path Computation Reply Message";
            reference "https://tools.ietf.org/html/rfc5440#section-6.5";

            uses message-header;

            list replies {
                uses pcep-object:replies;
            }
        }
    }

    // Stateful Messages

    grouping pcupd-message {
        uses message;

        container pcupd-message {
            description "State Update Request Message";
            reference "https://tools.ietf.org/html/rfc8231#section-6.2";

            uses message-header;

            list updates {
                uses pcep-object:srp-object;

                uses pcep-object:lsp-object;

                uses pcep-object:association-object;

                container path {
                    uses pcep-object:path-definition;
                }
            }
        }
    }

    grouping pcrpt-message {
        uses message;

        container pcrpt-message {
            description "State Report Message";
            reference "https://tools.ietf.org/html/rfc8231#section-6.1";

            uses message-header;

            list reports {
                uses pcep-object:srp-object;

                uses pcep-object:lsp-object;

                uses pcep-object:association-object;

                container path {
                    uses pcep-object:path-definition;
                }
            }
        }
    }

    grouping pcinitiate-message {
        uses message;

        container pcinitiate-message {
            description "LSP Initiate Message";
            reference "http://tools.ietf.org/html/rfc8281#section-5.1";

            uses message-header;

            list requests {
                uses pcep-object:srp-object;

                uses pcep-object:lsp-object;

                uses pcep-object:endpoints-object;

                uses pcep-object:explicit-route-object;

                uses pcep-object:association-object;

                uses pcep-object:lsp-attributes;
            }
        }
    }

    // Notifications

    notification open {
        uses open-message;
    }

    notification keepalive {
        uses keepalive-message;
    }

    notification pcreq {
        uses pcreq-message;
    }

    notification pcrep {
        uses pcrep-message;
    }

    notification pcntf {
        uses pcntf-message;
    }

    notification pcerr {
        uses pcerr-message;
    }

    notification close {
        uses close-message;
    }

    notification starttls {
        uses start-tls-message;
    }

    notification pcmonreq {
        uses pcreq-message;
    }

    notification pcmonrep {
        uses pcmonrep-message;
    }

    notification pcupd {
        uses pcupd-message;
    }

    notification pcrpt {
        uses pcrpt-message;
    }

    notification pcinitiate {
        uses pcinitiate-message;
    }
}