opendaylight/md-sal/sal-rest-docgen/src/test/resources/topology.json

   1 {
   2     "apiVersion" : "1.0.0",
   3     "swaggerVersion" : "1.2",
   4     "basePath" : "http://10.195.128.107:8080/restconf",
   5     "resourcePath" : null,
   6     "produces" : [ "application/json", "application/xml" ],
   7     "apis" : [ {
   8         "path" : "/operational/network-topology:network-topology",
   9         "operations" : [ {
  10             "method" : "GET",
  11             "summary" : null,
  12             "notes" : null,
  13             "type" : "network-topology",
  14             "nickname" : "GET-network-topology",
  15             "consumes" : null,
  16             "parameters" : [ ],
  17             "responseMessages" : null
  18         } ]
  19     }, {
  20         "path" : "/operational/network-topology:network-topology/topology/{topology-id}",
  21         "operations" : [ {
  22             "method" : "GET",
  23             "summary" : null,
  24             "notes" : "\n                This is the model of an abstract topology.\n                A topology contins nodes and links.  \n                Each topology MUST be identified by\n                unique topology-id for reason that a network could contain many\n                topologies.\n            ",
  25             "type" : "topology",
  26             "nickname" : "GET-topology",
  27             "consumes" : null,
  28             "parameters" : [ {
  29                 "name" : "topology-id",
  30                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
  31                 "required" : false,
  32                 "type" : "string",
  33                 "paramType" : "path"
  34             } ],
  35             "responseMessages" : null
  36         } ]
  37     }, {
  38         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}",
  39         "operations" : [ {
  40             "method" : "GET",
  41             "summary" : null,
  42             "notes" : "\n                    A Network Link connects a by Local (Source) node and\n                    a Remote (Destination) Network Nodes via a set of the \n                    nodes' termination points. \n                    As it is possible to have several links between the same\n                    source and destination nodes, and as a link could potentially\n                    be re-homed between termination points, to ensure that we \n                    would always know to distinguish between links, every link \n                    is identified by a dedicated link identifier.  \n                    Note that a link models a point-to-point link, not a multipoint\n                    link.  \n                    Layering dependencies on links in underlay topologies are\n                    not represented as the layering information of nodes and of \n                    termination points is sufficient.  \n                ",
  43             "type" : "link",
  44             "nickname" : "GET-link",
  45             "consumes" : null,
  46             "parameters" : [ {
  47                 "name" : "topology-id",
  48                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
  49                 "required" : false,
  50                 "type" : "string",
  51                 "paramType" : "path"
  52             }, {
  53                 "name" : "link-id",
  54                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
  55                 "required" : false,
  56                 "type" : "string",
  57                 "paramType" : "path"
  58             } ],
  59             "responseMessages" : null
  60         } ]
  61     }, {
  62         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/destination",
  63         "operations" : [ {
  64             "method" : "GET",
  65             "summary" : null,
  66             "notes" : null,
  67             "type" : "destination",
  68             "nickname" : "GET-destination",
  69             "consumes" : null,
  70             "parameters" : [ {
  71                 "name" : "topology-id",
  72                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
  73                 "required" : false,
  74                 "type" : "string",
  75                 "paramType" : "path"
  76             }, {
  77                 "name" : "link-id",
  78                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
  79                 "required" : false,
  80                 "type" : "string",
  81                 "paramType" : "path"
  82             } ],
  83             "responseMessages" : null
  84         } ]
  85     }, {
  86         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/destination/dest-node",
  87         "operations" : [ {
  88             "method" : "GET",
  89             "summary" : null,
  90             "notes" : "Destination node identifier, must be in same topology.",
  91             "type" : "dest-node",
  92             "nickname" : "GET-dest-node",
  93             "consumes" : null,
  94             "parameters" : [ {
  95                 "name" : "topology-id",
  96                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
  97                 "required" : false,
  98                 "type" : "string",
  99                 "paramType" : "path"
 100             }, {
 101                 "name" : "link-id",
 102                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 103                 "required" : false,
 104                 "type" : "string",
 105                 "paramType" : "path"
 106             } ],
 107             "responseMessages" : null
 108         } ]
 109     }, {
 110         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/destination/dest-tp",
 111         "operations" : [ {
 112             "method" : "GET",
 113             "summary" : null,
 114             "notes" : "Termination point within destination node that terminates the link.",
 115             "type" : "dest-tp",
 116             "nickname" : "GET-dest-tp",
 117             "consumes" : null,
 118             "parameters" : [ {
 119                 "name" : "topology-id",
 120                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 121                 "required" : false,
 122                 "type" : "string",
 123                 "paramType" : "path"
 124             }, {
 125                 "name" : "link-id",
 126                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 127                 "required" : false,
 128                 "type" : "string",
 129                 "paramType" : "path"
 130             } ],
 131             "responseMessages" : null
 132         } ]
 133     }, {
 134         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/link-id",
 135         "operations" : [ {
 136             "method" : "GET",
 137             "summary" : null,
 138             "notes" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 139             "type" : "link-id",
 140             "nickname" : "GET-link-id",
 141             "consumes" : null,
 142             "parameters" : [ {
 143                 "name" : "topology-id",
 144                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 145                 "required" : false,
 146                 "type" : "string",
 147                 "paramType" : "path"
 148             }, {
 149                 "name" : "link-id",
 150                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 151                 "required" : false,
 152                 "type" : "string",
 153                 "paramType" : "path"
 154             } ],
 155             "responseMessages" : null
 156         } ]
 157     }, {
 158         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/source",
 159         "operations" : [ {
 160             "method" : "GET",
 161             "summary" : null,
 162             "notes" : null,
 163             "type" : "source",
 164             "nickname" : "GET-source",
 165             "consumes" : null,
 166             "parameters" : [ {
 167                 "name" : "topology-id",
 168                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 169                 "required" : false,
 170                 "type" : "string",
 171                 "paramType" : "path"
 172             }, {
 173                 "name" : "link-id",
 174                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 175                 "required" : false,
 176                 "type" : "string",
 177                 "paramType" : "path"
 178             } ],
 179             "responseMessages" : null
 180         } ]
 181     }, {
 182         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/source/source-node",
 183         "operations" : [ {
 184             "method" : "GET",
 185             "summary" : null,
 186             "notes" : "Source node identifier, must be in same topology.",
 187             "type" : "source-node",
 188             "nickname" : "GET-source-node",
 189             "consumes" : null,
 190             "parameters" : [ {
 191                 "name" : "topology-id",
 192                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 193                 "required" : false,
 194                 "type" : "string",
 195                 "paramType" : "path"
 196             }, {
 197                 "name" : "link-id",
 198                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 199                 "required" : false,
 200                 "type" : "string",
 201                 "paramType" : "path"
 202             } ],
 203             "responseMessages" : null
 204         } ]
 205     }, {
 206         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/source/source-tp",
 207         "operations" : [ {
 208             "method" : "GET",
 209             "summary" : null,
 210             "notes" : "Termination point within source node that terminates the link.",
 211             "type" : "source-tp",
 212             "nickname" : "GET-source-tp",
 213             "consumes" : null,
 214             "parameters" : [ {
 215                 "name" : "topology-id",
 216                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 217                 "required" : false,
 218                 "type" : "string",
 219                 "paramType" : "path"
 220             }, {
 221                 "name" : "link-id",
 222                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 223                 "required" : false,
 224                 "type" : "string",
 225                 "paramType" : "path"
 226             } ],
 227             "responseMessages" : null
 228         } ]
 229     }, {
 230         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/supporting-link/{link-ref}",
 231         "operations" : [ {
 232             "method" : "GET",
 233             "summary" : null,
 234             "notes" : null,
 235             "type" : "supporting-link",
 236             "nickname" : "GET-supporting-link",
 237             "consumes" : null,
 238             "parameters" : [ {
 239                 "name" : "topology-id",
 240                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 241                 "required" : false,
 242                 "type" : "string",
 243                 "paramType" : "path"
 244             }, {
 245                 "name" : "link-id",
 246                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 247                 "required" : false,
 248                 "type" : "string",
 249                 "paramType" : "path"
 250             }, {
 251                 "name" : "link-ref",
 252                 "description" : null,
 253                 "required" : false,
 254                 "type" : "string",
 255                 "paramType" : "path"
 256             } ],
 257             "responseMessages" : null
 258         } ]
 259     }, {
 260         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/link/{link-id}/supporting-link/{link-ref}/link-ref",
 261         "operations" : [ {
 262             "method" : "GET",
 263             "summary" : null,
 264             "notes" : null,
 265             "type" : "link-ref",
 266             "nickname" : "GET-link-ref",
 267             "consumes" : null,
 268             "parameters" : [ {
 269                 "name" : "topology-id",
 270                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 271                 "required" : false,
 272                 "type" : "string",
 273                 "paramType" : "path"
 274             }, {
 275                 "name" : "link-id",
 276                 "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 277                 "required" : false,
 278                 "type" : "string",
 279                 "paramType" : "path"
 280             }, {
 281                 "name" : "link-ref",
 282                 "description" : null,
 283                 "required" : false,
 284                 "type" : "string",
 285                 "paramType" : "path"
 286             } ],
 287             "responseMessages" : null
 288         } ]
 289     }, {
 290         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}",
 291         "operations" : [ {
 292             "method" : "GET",
 293             "summary" : null,
 294             "notes" : "The list of network nodes defined for the topology.",
 295             "type" : "node",
 296             "nickname" : "GET-node",
 297             "consumes" : null,
 298             "parameters" : [ {
 299                 "name" : "topology-id",
 300                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 301                 "required" : false,
 302                 "type" : "string",
 303                 "paramType" : "path"
 304             }, {
 305                 "name" : "node-id",
 306                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 307                 "required" : false,
 308                 "type" : "string",
 309                 "paramType" : "path"
 310             } ],
 311             "responseMessages" : null
 312         } ]
 313     }, {
 314         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}/node-id",
 315         "operations" : [ {
 316             "method" : "GET",
 317             "summary" : null,
 318             "notes" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 319             "type" : "node-id",
 320             "nickname" : "GET-node-id",
 321             "consumes" : null,
 322             "parameters" : [ {
 323                 "name" : "topology-id",
 324                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 325                 "required" : false,
 326                 "type" : "string",
 327                 "paramType" : "path"
 328             }, {
 329                 "name" : "node-id",
 330                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 331                 "required" : false,
 332                 "type" : "string",
 333                 "paramType" : "path"
 334             } ],
 335             "responseMessages" : null
 336         } ]
 337     }, {
 338         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}/supporting-node/{node-ref}",
 339         "operations" : [ {
 340             "method" : "GET",
 341             "summary" : null,
 342             "notes" : "This list defines vertical layering information for nodes. \n                It allows to capture for any given node, which node (or nodes)\n                in the corresponding underlay topology it maps onto.  \n                A node can map to zero, one, or more nodes below it;\n                accordingly there can be zero, one, or more elements in the list.\n                If there are specific layering requirements, for example\n                specific to a particular type of topology that only allows\n                for certain layering relationships, the choice\n                below can be augmented with additional cases.\n                A list has been chosen rather than a leaf-list in order \n                to provide room for augmentations, e.g. for \n                statistics or priorization information associated with \n                supporting nodes.",
 343             "type" : "supporting-node",
 344             "nickname" : "GET-supporting-node",
 345             "consumes" : null,
 346             "parameters" : [ {
 347                 "name" : "topology-id",
 348                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 349                 "required" : false,
 350                 "type" : "string",
 351                 "paramType" : "path"
 352             }, {
 353                 "name" : "node-id",
 354                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 355                 "required" : false,
 356                 "type" : "string",
 357                 "paramType" : "path"
 358             }, {
 359                 "name" : "node-ref",
 360                 "description" : null,
 361                 "required" : false,
 362                 "type" : "string",
 363                 "paramType" : "path"
 364             } ],
 365             "responseMessages" : null
 366         } ]
 367     }, {
 368         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}/supporting-node/{node-ref}/node-ref",
 369         "operations" : [ {
 370             "method" : "GET",
 371             "summary" : null,
 372             "notes" : null,
 373             "type" : "node-ref",
 374             "nickname" : "GET-node-ref",
 375             "consumes" : null,
 376             "parameters" : [ {
 377                 "name" : "topology-id",
 378                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 379                 "required" : false,
 380                 "type" : "string",
 381                 "paramType" : "path"
 382             }, {
 383                 "name" : "node-id",
 384                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 385                 "required" : false,
 386                 "type" : "string",
 387                 "paramType" : "path"
 388             }, {
 389                 "name" : "node-ref",
 390                 "description" : null,
 391                 "required" : false,
 392                 "type" : "string",
 393                 "paramType" : "path"
 394             } ],
 395             "responseMessages" : null
 396         } ]
 397     }, {
 398         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}/termination-point/{tp-id}",
 399         "operations" : [ {
 400             "method" : "GET",
 401             "summary" : null,
 402             "notes" : "A termination point can terminate a link.  \n                        Depending on the type of topology, a termination point could, \n                        for example, refer to a port or an interface.",
 403             "type" : "termination-point",
 404             "nickname" : "GET-termination-point",
 405             "consumes" : null,
 406             "parameters" : [ {
 407                 "name" : "topology-id",
 408                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 409                 "required" : false,
 410                 "type" : "string",
 411                 "paramType" : "path"
 412             }, {
 413                 "name" : "node-id",
 414                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 415                 "required" : false,
 416                 "type" : "string",
 417                 "paramType" : "path"
 418             }, {
 419                 "name" : "tp-id",
 420                 "description" : null,
 421                 "required" : false,
 422                 "type" : "string",
 423                 "paramType" : "path"
 424             } ],
 425             "responseMessages" : null
 426         } ]
 427     }, {
 428         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}/termination-point/{tp-id}/tp-id",
 429         "operations" : [ {
 430             "method" : "GET",
 431             "summary" : null,
 432             "notes" : null,
 433             "type" : "tp-id",
 434             "nickname" : "GET-tp-id",
 435             "consumes" : null,
 436             "parameters" : [ {
 437                 "name" : "topology-id",
 438                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 439                 "required" : false,
 440                 "type" : "string",
 441                 "paramType" : "path"
 442             }, {
 443                 "name" : "node-id",
 444                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 445                 "required" : false,
 446                 "type" : "string",
 447                 "paramType" : "path"
 448             }, {
 449                 "name" : "tp-id",
 450                 "description" : null,
 451                 "required" : false,
 452                 "type" : "string",
 453                 "paramType" : "path"
 454             } ],
 455             "responseMessages" : null
 456         } ]
 457     }, {
 458         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/node/{node-id}/termination-point/{tp-id}/tp-ref",
 459         "operations" : [ {
 460             "method" : "GET",
 461             "summary" : null,
 462             "notes" : "The leaf list identifies any termination points that the \n                termination point is dependent on, or maps onto.  \n                Those termination points will themselves be contained \n                in a supporting node.  \n                This dependency information can be inferred from \n                the dependencies between links.  For this reason, \n                this item is not separately configurable.  Hence no\n                corresponding constraint needs to be articulated.  \n                The corresponding information is simply provided by the\n                implementing system.",
 463             "type" : "tp-ref",
 464             "nickname" : "GET-tp-ref",
 465             "consumes" : null,
 466             "parameters" : [ {
 467                 "name" : "topology-id",
 468                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 469                 "required" : false,
 470                 "type" : "string",
 471                 "paramType" : "path"
 472             }, {
 473                 "name" : "node-id",
 474                 "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 475                 "required" : false,
 476                 "type" : "string",
 477                 "paramType" : "path"
 478             }, {
 479                 "name" : "tp-id",
 480                 "description" : null,
 481                 "required" : false,
 482                 "type" : "string",
 483                 "paramType" : "path"
 484             } ],
 485             "responseMessages" : null
 486         } ]
 487     }, {
 488         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/topology-id",
 489         "operations" : [ {
 490             "method" : "GET",
 491             "summary" : null,
 492             "notes" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 493             "type" : "topology-id",
 494             "nickname" : "GET-topology-id",
 495             "consumes" : null,
 496             "parameters" : [ {
 497                 "name" : "topology-id",
 498                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 499                 "required" : false,
 500                 "type" : "string",
 501                 "paramType" : "path"
 502             } ],
 503             "responseMessages" : null
 504         } ]
 505     }, {
 506         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/topology-types",
 507         "operations" : [ {
 508             "method" : "GET",
 509             "summary" : null,
 510             "notes" : "This container is used to identify the type, or types \n                    (as a topology can support several types simultaneously), \n                    of the topology.  \n                    Topology types are the subject of several integrity constraints \n                    that an implementing server can validate in order to \n                    maintain integrity of the datastore.  \n                    Topology types are indicated through separate data nodes; \n                    the set of topology types is expected to increase over time.\n                    To add support for a new topology, an augmenting module\n                    needs to augment this container with a new empty optional \n                    container to indicate the new topology type.  \n                    The use of a container allows to indicate a subcategorization\n                    of topology types.  \n                    The container SHALL NOT be augmented with any data nodes \n                    that serve a purpose other than identifying a particular \n                    topology type.  \n                ",
 511             "type" : "topology-types",
 512             "nickname" : "GET-topology-types",
 513             "consumes" : null,
 514             "parameters" : [ {
 515                 "name" : "topology-id",
 516                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 517                 "required" : false,
 518                 "type" : "string",
 519                 "paramType" : "path"
 520             } ],
 521             "responseMessages" : null
 522         } ]
 523     }, {
 524         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/underlay-topology/{topology-ref}",
 525         "operations" : [ {
 526             "method" : "GET",
 527             "summary" : null,
 528             "notes" : "Identifies the topology, or topologies, that this topology\n                    is dependent on.",
 529             "type" : "underlay-topology",
 530             "nickname" : "GET-underlay-topology",
 531             "consumes" : null,
 532             "parameters" : [ {
 533                 "name" : "topology-id",
 534                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 535                 "required" : false,
 536                 "type" : "string",
 537                 "paramType" : "path"
 538             }, {
 539                 "name" : "topology-ref",
 540                 "description" : null,
 541                 "required" : false,
 542                 "type" : "string",
 543                 "paramType" : "path"
 544             } ],
 545             "responseMessages" : null
 546         } ]
 547     }, {
 548         "path" : "/operational/network-topology:network-topology/topology/{topology-id}/underlay-topology/{topology-ref}/topology-ref",
 549         "operations" : [ {
 550             "method" : "GET",
 551             "summary" : null,
 552             "notes" : null,
 553             "type" : "topology-ref",
 554             "nickname" : "GET-topology-ref",
 555             "consumes" : null,
 556             "parameters" : [ {
 557                 "name" : "topology-id",
 558                 "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 559                 "required" : false,
 560                 "type" : "string",
 561                 "paramType" : "path"
 562             }, {
 563                 "name" : "topology-ref",
 564                 "description" : null,
 565                 "required" : false,
 566                 "type" : "string",
 567                 "paramType" : "path"
 568             } ],
 569             "responseMessages" : null
 570         } ]
 571     } ],
 572     "models" : {
 573         "underlay-topology" : {
 574             "id" : "underlay-topology",
 575             "$schema" : "http://json-schema.org/draft-04/schema",
 576             "properties" : {
 577                 "topology-ref" : {
 578                     "required" : false
 579                 }
 580             },
 581             "type" : "object"
 582         },
 583         "network-topology" : "{\n  \"id\": \"network-topology\",\n  \"$schema\": \"http://json-schema.org/draft-04/schema\",\n  \"properties\": {\"topology\": {\n    \"items\": {\"$ref\": \"topology\"},\n    \"description\": \"\\n                This is the model of an abstract topology.\\n                A topology contins nodes and links.  \\n                Each topology MUST be identified by\\n                unique topology-id for reason that a network could contain many\\n                topologies.\\n            \",\n    \"type\": \"array\"\n  }},\n  \"type\": \"object\"\n}",
 584         "node" : {
 585             "id" : "node",
 586             "$schema" : "http://json-schema.org/draft-04/schema",
 587             "properties" : {
 588                 "supporting-node" : {
 589                     "items" : {
 590                         "$ref" : "supporting-node"
 591                     },
 592                     "description" : "This list defines vertical layering information for nodes. \n                It allows to capture for any given node, which node (or nodes)\n                in the corresponding underlay topology it maps onto.  \n                A node can map to zero, one, or more nodes below it;\n                accordingly there can be zero, one, or more elements in the list.\n                If there are specific layering requirements, for example\n                specific to a particular type of topology that only allows\n                for certain layering relationships, the choice\n                below can be augmented with additional cases.\n                A list has been chosen rather than a leaf-list in order \n                to provide room for augmentations, e.g. for \n                statistics or priorization information associated with \n                supporting nodes.",
 593                     "type" : "array"
 594                 },
 595                 "termination-point" : {
 596                     "items" : {
 597                         "$ref" : "termination-point"
 598                     },
 599                     "description" : "A termination point can terminate a link.  \n                        Depending on the type of topology, a termination point could, \n                        for example, refer to a port or an interface.",
 600                     "type" : "array"
 601                 },
 602                 "node-id" : {
 603                     "description" : "The identifier of a node in the topology.  \n                A node is specific to a topology to which it belongs.",
 604                     "type" : "string",
 605                     "required" : false
 606                 }
 607             },
 608             "type" : "object"
 609         },
 610         "supporting-node" : {
 611             "id" : "supporting-node",
 612             "$schema" : "http://json-schema.org/draft-04/schema",
 613             "properties" : {
 614                 "node-ref" : {
 615                     "required" : false
 616                 }
 617             },
 618             "type" : "object"
 619         },
 620         "link" : {
 621             "id" : "link",
 622             "$schema" : "http://json-schema.org/draft-04/schema",
 623             "properties" : {
 624                 "source" : {
 625                     "properties" : {
 626                         "source-node" : {
 627                             "description" : "Source node identifier, must be in same topology.",
 628                             "required" : true
 629                         },
 630                         "source-tp" : {
 631                             "description" : "Termination point within source node that terminates the link.",
 632                             "required" : false
 633                         }
 634                     },
 635                     "type" : "object"
 636                 },
 637                 "supporting-link" : {
 638                     "items" : {
 639                         "$ref" : "supporting-link"
 640                     },
 641                     "type" : "array"
 642                 },
 643                 "link-id" : {
 644                     "description" : "The identifier of a link in the topology.  \n                A link is specific to a topology to which it belongs.",
 645                     "type" : "string",
 646                     "required" : false
 647                 },
 648                 "destination" : {
 649                     "properties" : {
 650                         "dest-node" : {
 651                             "description" : "Destination node identifier, must be in same topology.",
 652                             "required" : true
 653                         },
 654                         "dest-tp" : {
 655                             "description" : "Termination point within destination node that terminates the link.",
 656                             "required" : false
 657                         }
 658                     },
 659                     "type" : "object"
 660                 }
 661             },
 662             "type" : "object"
 663         },
 664         "termination-point" : {
 665             "id" : "termination-point",
 666             "$schema" : "http://json-schema.org/draft-04/schema",
 667             "properties" : {
 668                 "tp-ref" : {
 669                     "items" : { },
 670                     "description" : "The leaf list identifies any termination points that the \n                termination point is dependent on, or maps onto.  \n                Those termination points will themselves be contained \n                in a supporting node.  \n                This dependency information can be inferred from \n                the dependencies between links.  For this reason, \n                this item is not separately configurable.  Hence no\n                corresponding constraint needs to be articulated.  \n                The corresponding information is simply provided by the\n                implementing system.",
 671                     "required" : false,
 672                     "type" : "array"
 673                 },
 674                 "tp-id" : {
 675                     "type" : "string",
 676                     "required" : false
 677                 }
 678             },
 679             "type" : "object"
 680         },
 681         "topology" : {
 682             "id" : "topology",
 683             "$schema" : "http://json-schema.org/draft-04/schema",
 684             "properties" : {
 685                 "underlay-topology" : {
 686                     "items" : {
 687                         "$ref" : "underlay-topology"
 688                     },
 689                     "description" : "Identifies the topology, or topologies, that this topology\n                    is dependent on.",
 690                     "type" : "array"
 691                 },
 692                 "node" : {
 693                     "items" : {
 694                         "$ref" : "node"
 695                     },
 696                     "description" : "The list of network nodes defined for the topology.",
 697                     "type" : "array"
 698                 },
 699                 "topology-types" : {
 700                     "description" : "This container is used to identify the type, or types \n                    (as a topology can support several types simultaneously), \n                    of the topology.  \n                    Topology types are the subject of several integrity constraints \n                    that an implementing server can validate in order to \n                    maintain integrity of the datastore.  \n                    Topology types are indicated through separate data nodes; \n                    the set of topology types is expected to increase over time.\n                    To add support for a new topology, an augmenting module\n                    needs to augment this container with a new empty optional \n                    container to indicate the new topology type.  \n                    The use of a container allows to indicate a subcategorization\n                    of topology types.  \n                    The container SHALL NOT be augmented with any data nodes \n                    that serve a purpose other than identifying a particular \n                    topology type.  \n                ",
 701                     "properties" : { },
 702                     "type" : "object"
 703                 },
 704                 "topology-id" : {
 705                     "description" : "\n                    It is presumed that a datastore will contain many topologies. To\n                    distinguish between topologies it is vital to have UNIQUE\n                    topology identifiers.\n                ",
 706                     "type" : "string",
 707                     "required" : false
 708                 },
 709                 "link" : {
 710                     "items" : {
 711                         "$ref" : "link"
 712                     },
 713                     "description" : "\n                    A Network Link connects a by Local (Source) node and\n                    a Remote (Destination) Network Nodes via a set of the \n                    nodes' termination points. \n                    As it is possible to have several links between the same\n                    source and destination nodes, and as a link could potentially\n                    be re-homed between termination points, to ensure that we \n                    would always know to distinguish between links, every link \n                    is identified by a dedicated link identifier.  \n                    Note that a link models a point-to-point link, not a multipoint\n                    link.  \n                    Layering dependencies on links in underlay topologies are\n                    not represented as the layering information of nodes and of \n                    termination points is sufficient.  \n                ",
 714                     "type" : "array"
 715                 }
 716             },
 717             "type" : "object"
 718         },
 719         "supporting-link" : {
 720             "id" : "supporting-link",
 721             "$schema" : "http://json-schema.org/draft-04/schema",
 722             "properties" : {
 723                 "link-ref" : {
 724                     "required" : false
 725                 }
 726             },
 727             "type" : "object"
 728         }
 729     }
 730 }