1 package org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105;
2 import org.opendaylight.yangtools.yang.binding.DataObject;
3 import org.opendaylight.yangtools.yang.common.QName;
4 import org.opendaylight.yangtools.yang.binding.Augmentable;
5 import org.opendaylight.yangtools.yang.binding.Notification;
6
7 /**
8 * <p>This class represents the following YANG schema fragment defined in module <b>odl-lisp-proto</b>
9 * <pre>
10 * notification xtrRequestMapping {
11 * container MapRequest {
12 * leaf authoritative {
13 * type boolean;
14 * }
15 * leaf mapDataPresent {
16 * type boolean;
17 * }
18 * leaf probe {
19 * type boolean;
20 * }
21 * leaf smr {
22 * type boolean;
23 * }
24 * leaf pitr {
25 * type boolean;
26 * }
27 * leaf smrInvoked {
28 * type boolean;
29 * }
30 * leaf nonce {
31 * type int64;
32 * }
33 * container SourceEid {
34 * container eid {
35 * leaf address-type {
36 * type lisp-address-family-ref;
37 * }
38 * leaf virtual-network-id {
39 * type instance-id-type;
40 * }
41 * choice address {
42 * case afi-list {
43 * container afi-list {
44 * leaf-list address-list {
45 * type simple-address;
46 * }
47 * }
48 * }
49 * case application-data {
50 * container application-data {
51 * leaf address {
52 * type simple-address;
53 * }
54 * leaf protocol {
55 * type uint8;
56 * }
57 * leaf ip-tos {
58 * type int32;
59 * }
60 * leaf local-port-low {
61 * type port-number;
62 * }
63 * leaf local-port-high {
64 * type port-number;
65 * }
66 * leaf remote-port-low {
67 * type port-number;
68 * }
69 * leaf remote-port-high {
70 * type port-number;
71 * }
72 * }
73 * }
74 * case as-number {
75 * leaf as-number {
76 * type as-number;
77 * }
78 * }
79 * case as-number-lcaf {
80 * container as-number-lcaf {
81 * leaf as {
82 * type as-number;
83 * }
84 * leaf address {
85 * type simple-address;
86 * }
87 * }
88 * }
89 * case distinguished-name {
90 * leaf distinguished-name {
91 * type distinguished-name-type;
92 * }
93 * }
94 * case explicit-locator-path {
95 * container explicit-locator-path {
96 * list hop {
97 * key "hop-id"
98 * leaf hop-id {
99 * type string;
100 * }
101 * leaf address {
102 * type simple-address;
103 * }
104 * leaf lrs-bits {
105 * type bits;
106 * }
107 * }
108 * }
109 * }
110 * case geo-coordinates {
111 * container geo-coordinates {
112 * leaf latitude {
113 * type bits;
114 * }
115 * leaf latitude-degrees {
116 * type uint8;
117 * }
118 * leaf latitude-minutes {
119 * type uint8;
120 * }
121 * leaf latitude-seconds {
122 * type uint8;
123 * }
124 * leaf longitude {
125 * type bits;
126 * }
127 * leaf longitude-degrees {
128 * type uint16;
129 * }
130 * leaf longitude-minutes {
131 * type uint8;
132 * }
133 * leaf longitude-seconds {
134 * type uint8;
135 * }
136 * leaf altitude {
137 * type int32;
138 * }
139 * leaf address {
140 * type simple-address;
141 * }
142 * }
143 * }
144 * case instance-id {
145 * container instance-id {
146 * leaf iid {
147 * type instance-id-type;
148 * }
149 * leaf mask-length {
150 * type uint8;
151 * }
152 * leaf address {
153 * type simple-address;
154 * }
155 * }
156 * }
157 * case ipv4 {
158 * leaf ipv4 {
159 * type ipv4-address;
160 * }
161 * }
162 * case ipv4-binary {
163 * leaf ipv4-binary {
164 * type ipv4-address-binary;
165 * }
166 * }
167 * case ipv4-prefix {
168 * leaf ipv4-prefix {
169 * type ipv4-prefix;
170 * }
171 * }
172 * case ipv4-prefix-binary {
173 * leaf ipv4-address-binary {
174 * type ipv4-address-binary;
175 * }
176 * leaf ipv4-mask-length {
177 * type uint8;
178 * }
179 * }
180 * case ipv6 {
181 * leaf ipv6 {
182 * type ipv6-address;
183 * }
184 * }
185 * case ipv6-binary {
186 * leaf ipv6-binary {
187 * type ipv6-address-binary;
188 * }
189 * }
190 * case ipv6-prefix {
191 * leaf ipv6-prefix {
192 * type ipv6-prefix;
193 * }
194 * }
195 * case ipv6-prefix-binary {
196 * leaf ipv6-address-binary {
197 * type ipv6-address-binary;
198 * }
199 * leaf ipv6-mask-length {
200 * type uint8;
201 * }
202 * }
203 * case key-value-address {
204 * container key-value-address {
205 * leaf key {
206 * type simple-address;
207 * }
208 * leaf value {
209 * type simple-address;
210 * }
211 * }
212 * }
213 * case mac {
214 * leaf mac {
215 * type mac-address;
216 * }
217 * }
218 * case nat-traversal {
219 * container nat-traversal {
220 * leaf ms-udp-port {
221 * type uint16;
222 * }
223 * leaf etr-udp-port {
224 * type uint16;
225 * }
226 * leaf global-etr-rloc {
227 * type simple-address;
228 * }
229 * leaf ms-rloc {
230 * type simple-address;
231 * }
232 * leaf private-etr-rloc {
233 * type simple-address;
234 * }
235 * leaf-list rtr-rlocs {
236 * type simple-address;
237 * }
238 * }
239 * }
240 * case no-address {
241 * leaf no-address {
242 * type empty;
243 * }
244 * }
245 * case null-address {
246 * container null-address {
247 * leaf address {
248 * type empty;
249 * }
250 * }
251 * }
252 * case service-path {
253 * container service-path {
254 * leaf service-path-id {
255 * type service-path-id-type;
256 * }
257 * leaf service-index {
258 * type uint8;
259 * }
260 * }
261 * }
262 * case source-dest-key {
263 * container source-dest-key {
264 * leaf source {
265 * type simple-address;
266 * }
267 * leaf dest {
268 * type simple-address;
269 * }
270 * }
271 * }
272 * }
273 * uses augmented-lisp-address;
274 * }
275 * uses eid-container;
276 * }
277 * list itrRloc {
278 * key "itr-rloc-id"
279 * leaf itr-rloc-id {
280 * type string;
281 * }
282 * container rloc {
283 * leaf address-type {
284 * type lisp-address-family-ref;
285 * }
286 * leaf virtual-network-id {
287 * type instance-id-type;
288 * }
289 * choice address {
290 * case afi-list {
291 * container afi-list {
292 * leaf-list address-list {
293 * type simple-address;
294 * }
295 * }
296 * }
297 * case application-data {
298 * container application-data {
299 * leaf address {
300 * type simple-address;
301 * }
302 * leaf protocol {
303 * type uint8;
304 * }
305 * leaf ip-tos {
306 * type int32;
307 * }
308 * leaf local-port-low {
309 * type port-number;
310 * }
311 * leaf local-port-high {
312 * type port-number;
313 * }
314 * leaf remote-port-low {
315 * type port-number;
316 * }
317 * leaf remote-port-high {
318 * type port-number;
319 * }
320 * }
321 * }
322 * case as-number {
323 * leaf as-number {
324 * type as-number;
325 * }
326 * }
327 * case as-number-lcaf {
328 * container as-number-lcaf {
329 * leaf as {
330 * type as-number;
331 * }
332 * leaf address {
333 * type simple-address;
334 * }
335 * }
336 * }
337 * case distinguished-name {
338 * leaf distinguished-name {
339 * type distinguished-name-type;
340 * }
341 * }
342 * case explicit-locator-path {
343 * container explicit-locator-path {
344 * list hop {
345 * key "hop-id"
346 * leaf hop-id {
347 * type string;
348 * }
349 * leaf address {
350 * type simple-address;
351 * }
352 * leaf lrs-bits {
353 * type bits;
354 * }
355 * }
356 * }
357 * }
358 * case geo-coordinates {
359 * container geo-coordinates {
360 * leaf latitude {
361 * type bits;
362 * }
363 * leaf latitude-degrees {
364 * type uint8;
365 * }
366 * leaf latitude-minutes {
367 * type uint8;
368 * }
369 * leaf latitude-seconds {
370 * type uint8;
371 * }
372 * leaf longitude {
373 * type bits;
374 * }
375 * leaf longitude-degrees {
376 * type uint16;
377 * }
378 * leaf longitude-minutes {
379 * type uint8;
380 * }
381 * leaf longitude-seconds {
382 * type uint8;
383 * }
384 * leaf altitude {
385 * type int32;
386 * }
387 * leaf address {
388 * type simple-address;
389 * }
390 * }
391 * }
392 * case instance-id {
393 * container instance-id {
394 * leaf iid {
395 * type instance-id-type;
396 * }
397 * leaf mask-length {
398 * type uint8;
399 * }
400 * leaf address {
401 * type simple-address;
402 * }
403 * }
404 * }
405 * case ipv4 {
406 * leaf ipv4 {
407 * type ipv4-address;
408 * }
409 * }
410 * case ipv4-binary {
411 * leaf ipv4-binary {
412 * type ipv4-address-binary;
413 * }
414 * }
415 * case ipv4-prefix {
416 * leaf ipv4-prefix {
417 * type ipv4-prefix;
418 * }
419 * }
420 * case ipv4-prefix-binary {
421 * leaf ipv4-address-binary {
422 * type ipv4-address-binary;
423 * }
424 * leaf ipv4-mask-length {
425 * type uint8;
426 * }
427 * }
428 * case ipv6 {
429 * leaf ipv6 {
430 * type ipv6-address;
431 * }
432 * }
433 * case ipv6-binary {
434 * leaf ipv6-binary {
435 * type ipv6-address-binary;
436 * }
437 * }
438 * case ipv6-prefix {
439 * leaf ipv6-prefix {
440 * type ipv6-prefix;
441 * }
442 * }
443 * case ipv6-prefix-binary {
444 * leaf ipv6-address-binary {
445 * type ipv6-address-binary;
446 * }
447 * leaf ipv6-mask-length {
448 * type uint8;
449 * }
450 * }
451 * case key-value-address {
452 * container key-value-address {
453 * leaf key {
454 * type simple-address;
455 * }
456 * leaf value {
457 * type simple-address;
458 * }
459 * }
460 * }
461 * case mac {
462 * leaf mac {
463 * type mac-address;
464 * }
465 * }
466 * case nat-traversal {
467 * container nat-traversal {
468 * leaf ms-udp-port {
469 * type uint16;
470 * }
471 * leaf etr-udp-port {
472 * type uint16;
473 * }
474 * leaf global-etr-rloc {
475 * type simple-address;
476 * }
477 * leaf ms-rloc {
478 * type simple-address;
479 * }
480 * leaf private-etr-rloc {
481 * type simple-address;
482 * }
483 * leaf-list rtr-rlocs {
484 * type simple-address;
485 * }
486 * }
487 * }
488 * case no-address {
489 * leaf no-address {
490 * type empty;
491 * }
492 * }
493 * case null-address {
494 * container null-address {
495 * leaf address {
496 * type empty;
497 * }
498 * }
499 * }
500 * case service-path {
501 * container service-path {
502 * leaf service-path-id {
503 * type service-path-id-type;
504 * }
505 * leaf service-index {
506 * type uint8;
507 * }
508 * }
509 * }
510 * case source-dest-key {
511 * container source-dest-key {
512 * leaf source {
513 * type simple-address;
514 * }
515 * leaf dest {
516 * type simple-address;
517 * }
518 * }
519 * }
520 * }
521 * uses augmented-lisp-address;
522 * }
523 * uses rloc-container;
524 * }
525 * container MapReply {
526 * container mapping-record {
527 * leaf recordTtl {
528 * type int32;
529 * }
530 * leaf mapVersion {
531 * type int16;
532 * }
533 * leaf action {
534 * type enumeration;
535 * }
536 * leaf authoritative {
537 * type boolean;
538 * }
539 * leaf xtr-id {
540 * type xtr-id;
541 * }
542 * leaf site-id {
543 * type site-id;
544 * }
545 * leaf source-rloc {
546 * type ip-address-binary;
547 * }
548 * leaf timestamp {
549 * type int64;
550 * }
551 * container eid {
552 * leaf address-type {
553 * type lisp-address-family-ref;
554 * }
555 * leaf virtual-network-id {
556 * type instance-id-type;
557 * }
558 * choice address {
559 * case afi-list {
560 * container afi-list {
561 * leaf-list address-list {
562 * type simple-address;
563 * }
564 * }
565 * }
566 * case application-data {
567 * container application-data {
568 * leaf address {
569 * type simple-address;
570 * }
571 * leaf protocol {
572 * type uint8;
573 * }
574 * leaf ip-tos {
575 * type int32;
576 * }
577 * leaf local-port-low {
578 * type port-number;
579 * }
580 * leaf local-port-high {
581 * type port-number;
582 * }
583 * leaf remote-port-low {
584 * type port-number;
585 * }
586 * leaf remote-port-high {
587 * type port-number;
588 * }
589 * }
590 * }
591 * case as-number {
592 * leaf as-number {
593 * type as-number;
594 * }
595 * }
596 * case as-number-lcaf {
597 * container as-number-lcaf {
598 * leaf as {
599 * type as-number;
600 * }
601 * leaf address {
602 * type simple-address;
603 * }
604 * }
605 * }
606 * case distinguished-name {
607 * leaf distinguished-name {
608 * type distinguished-name-type;
609 * }
610 * }
611 * case explicit-locator-path {
612 * container explicit-locator-path {
613 * list hop {
614 * key "hop-id"
615 * leaf hop-id {
616 * type string;
617 * }
618 * leaf address {
619 * type simple-address;
620 * }
621 * leaf lrs-bits {
622 * type bits;
623 * }
624 * }
625 * }
626 * }
627 * case geo-coordinates {
628 * container geo-coordinates {
629 * leaf latitude {
630 * type bits;
631 * }
632 * leaf latitude-degrees {
633 * type uint8;
634 * }
635 * leaf latitude-minutes {
636 * type uint8;
637 * }
638 * leaf latitude-seconds {
639 * type uint8;
640 * }
641 * leaf longitude {
642 * type bits;
643 * }
644 * leaf longitude-degrees {
645 * type uint16;
646 * }
647 * leaf longitude-minutes {
648 * type uint8;
649 * }
650 * leaf longitude-seconds {
651 * type uint8;
652 * }
653 * leaf altitude {
654 * type int32;
655 * }
656 * leaf address {
657 * type simple-address;
658 * }
659 * }
660 * }
661 * case instance-id {
662 * container instance-id {
663 * leaf iid {
664 * type instance-id-type;
665 * }
666 * leaf mask-length {
667 * type uint8;
668 * }
669 * leaf address {
670 * type simple-address;
671 * }
672 * }
673 * }
674 * case ipv4 {
675 * leaf ipv4 {
676 * type ipv4-address;
677 * }
678 * }
679 * case ipv4-binary {
680 * leaf ipv4-binary {
681 * type ipv4-address-binary;
682 * }
683 * }
684 * case ipv4-prefix {
685 * leaf ipv4-prefix {
686 * type ipv4-prefix;
687 * }
688 * }
689 * case ipv4-prefix-binary {
690 * leaf ipv4-address-binary {
691 * type ipv4-address-binary;
692 * }
693 * leaf ipv4-mask-length {
694 * type uint8;
695 * }
696 * }
697 * case ipv6 {
698 * leaf ipv6 {
699 * type ipv6-address;
700 * }
701 * }
702 * case ipv6-binary {
703 * leaf ipv6-binary {
704 * type ipv6-address-binary;
705 * }
706 * }
707 * case ipv6-prefix {
708 * leaf ipv6-prefix {
709 * type ipv6-prefix;
710 * }
711 * }
712 * case ipv6-prefix-binary {
713 * leaf ipv6-address-binary {
714 * type ipv6-address-binary;
715 * }
716 * leaf ipv6-mask-length {
717 * type uint8;
718 * }
719 * }
720 * case key-value-address {
721 * container key-value-address {
722 * leaf key {
723 * type simple-address;
724 * }
725 * leaf value {
726 * type simple-address;
727 * }
728 * }
729 * }
730 * case mac {
731 * leaf mac {
732 * type mac-address;
733 * }
734 * }
735 * case nat-traversal {
736 * container nat-traversal {
737 * leaf ms-udp-port {
738 * type uint16;
739 * }
740 * leaf etr-udp-port {
741 * type uint16;
742 * }
743 * leaf global-etr-rloc {
744 * type simple-address;
745 * }
746 * leaf ms-rloc {
747 * type simple-address;
748 * }
749 * leaf private-etr-rloc {
750 * type simple-address;
751 * }
752 * leaf-list rtr-rlocs {
753 * type simple-address;
754 * }
755 * }
756 * }
757 * case no-address {
758 * leaf no-address {
759 * type empty;
760 * }
761 * }
762 * case null-address {
763 * container null-address {
764 * leaf address {
765 * type empty;
766 * }
767 * }
768 * }
769 * case service-path {
770 * container service-path {
771 * leaf service-path-id {
772 * type service-path-id-type;
773 * }
774 * leaf service-index {
775 * type uint8;
776 * }
777 * }
778 * }
779 * case source-dest-key {
780 * container source-dest-key {
781 * leaf source {
782 * type simple-address;
783 * }
784 * leaf dest {
785 * type simple-address;
786 * }
787 * }
788 * }
789 * }
790 * uses augmented-lisp-address;
791 * }
792 * list LocatorRecord {
793 * key "locator-id"
794 * leaf locator-id {
795 * type string;
796 * }
797 * leaf priority {
798 * type uint8;
799 * }
800 * leaf weight {
801 * type uint8;
802 * }
803 * leaf multicastPriority {
804 * type uint8;
805 * }
806 * leaf multicastWeight {
807 * type uint8;
808 * }
809 * leaf localLocator {
810 * type boolean;
811 * }
812 * leaf rlocProbed {
813 * type boolean;
814 * }
815 * leaf routed {
816 * type boolean;
817 * }
818 * container rloc {
819 * leaf address-type {
820 * type lisp-address-family-ref;
821 * }
822 * leaf virtual-network-id {
823 * type instance-id-type;
824 * }
825 * choice address {
826 * case afi-list {
827 * container afi-list {
828 * leaf-list address-list {
829 * type simple-address;
830 * }
831 * }
832 * }
833 * case application-data {
834 * container application-data {
835 * leaf address {
836 * type simple-address;
837 * }
838 * leaf protocol {
839 * type uint8;
840 * }
841 * leaf ip-tos {
842 * type int32;
843 * }
844 * leaf local-port-low {
845 * type port-number;
846 * }
847 * leaf local-port-high {
848 * type port-number;
849 * }
850 * leaf remote-port-low {
851 * type port-number;
852 * }
853 * leaf remote-port-high {
854 * type port-number;
855 * }
856 * }
857 * }
858 * case as-number {
859 * leaf as-number {
860 * type as-number;
861 * }
862 * }
863 * case as-number-lcaf {
864 * container as-number-lcaf {
865 * leaf as {
866 * type as-number;
867 * }
868 * leaf address {
869 * type simple-address;
870 * }
871 * }
872 * }
873 * case distinguished-name {
874 * leaf distinguished-name {
875 * type distinguished-name-type;
876 * }
877 * }
878 * case explicit-locator-path {
879 * container explicit-locator-path {
880 * list hop {
881 * key "hop-id"
882 * leaf hop-id {
883 * type string;
884 * }
885 * leaf address {
886 * type simple-address;
887 * }
888 * leaf lrs-bits {
889 * type bits;
890 * }
891 * }
892 * }
893 * }
894 * case geo-coordinates {
895 * container geo-coordinates {
896 * leaf latitude {
897 * type bits;
898 * }
899 * leaf latitude-degrees {
900 * type uint8;
901 * }
902 * leaf latitude-minutes {
903 * type uint8;
904 * }
905 * leaf latitude-seconds {
906 * type uint8;
907 * }
908 * leaf longitude {
909 * type bits;
910 * }
911 * leaf longitude-degrees {
912 * type uint16;
913 * }
914 * leaf longitude-minutes {
915 * type uint8;
916 * }
917 * leaf longitude-seconds {
918 * type uint8;
919 * }
920 * leaf altitude {
921 * type int32;
922 * }
923 * leaf address {
924 * type simple-address;
925 * }
926 * }
927 * }
928 * case instance-id {
929 * container instance-id {
930 * leaf iid {
931 * type instance-id-type;
932 * }
933 * leaf mask-length {
934 * type uint8;
935 * }
936 * leaf address {
937 * type simple-address;
938 * }
939 * }
940 * }
941 * case ipv4 {
942 * leaf ipv4 {
943 * type ipv4-address;
944 * }
945 * }
946 * case ipv4-binary {
947 * leaf ipv4-binary {
948 * type ipv4-address-binary;
949 * }
950 * }
951 * case ipv4-prefix {
952 * leaf ipv4-prefix {
953 * type ipv4-prefix;
954 * }
955 * }
956 * case ipv4-prefix-binary {
957 * leaf ipv4-address-binary {
958 * type ipv4-address-binary;
959 * }
960 * leaf ipv4-mask-length {
961 * type uint8;
962 * }
963 * }
964 * case ipv6 {
965 * leaf ipv6 {
966 * type ipv6-address;
967 * }
968 * }
969 * case ipv6-binary {
970 * leaf ipv6-binary {
971 * type ipv6-address-binary;
972 * }
973 * }
974 * case ipv6-prefix {
975 * leaf ipv6-prefix {
976 * type ipv6-prefix;
977 * }
978 * }
979 * case ipv6-prefix-binary {
980 * leaf ipv6-address-binary {
981 * type ipv6-address-binary;
982 * }
983 * leaf ipv6-mask-length {
984 * type uint8;
985 * }
986 * }
987 * case key-value-address {
988 * container key-value-address {
989 * leaf key {
990 * type simple-address;
991 * }
992 * leaf value {
993 * type simple-address;
994 * }
995 * }
996 * }
997 * case mac {
998 * leaf mac {
999 * type mac-address;
1000 * }
1001 * }
1002 * case nat-traversal {
1003 * container nat-traversal {
1004 * leaf ms-udp-port {
1005 * type uint16;
1006 * }
1007 * leaf etr-udp-port {
1008 * type uint16;
1009 * }
1010 * leaf global-etr-rloc {
1011 * type simple-address;
1012 * }
1013 * leaf ms-rloc {
1014 * type simple-address;
1015 * }
1016 * leaf private-etr-rloc {
1017 * type simple-address;
1018 * }
1019 * leaf-list rtr-rlocs {
1020 * type simple-address;
1021 * }
1022 * }
1023 * }
1024 * case no-address {
1025 * leaf no-address {
1026 * type empty;
1027 * }
1028 * }
1029 * case null-address {
1030 * container null-address {
1031 * leaf address {
1032 * type empty;
1033 * }
1034 * }
1035 * }
1036 * case service-path {
1037 * container service-path {
1038 * leaf service-path-id {
1039 * type service-path-id-type;
1040 * }
1041 * leaf service-index {
1042 * type uint8;
1043 * }
1044 * }
1045 * }
1046 * case source-dest-key {
1047 * container source-dest-key {
1048 * leaf source {
1049 * type simple-address;
1050 * }
1051 * leaf dest {
1052 * type simple-address;
1053 * }
1054 * }
1055 * }
1056 * }
1057 * uses augmented-lisp-address;
1058 * }
1059 * uses rloc-container;
1060 * }
1061 * uses eid-container;
1062 * uses LocatorRecords;
1063 * uses mapping-record-metadata;
1064 * }
1065 * uses mapping-record-container;
1066 * }
1067 * leaf source-rloc {
1068 * type ip-address-binary;
1069 * }
1070 * list eid-item {
1071 * key "eid-item-id"
1072 * leaf eid-item-id {
1073 * type string;
1074 * }
1075 * container eid {
1076 * leaf address-type {
1077 * type lisp-address-family-ref;
1078 * }
1079 * leaf virtual-network-id {
1080 * type instance-id-type;
1081 * }
1082 * choice address {
1083 * case afi-list {
1084 * container afi-list {
1085 * leaf-list address-list {
1086 * type simple-address;
1087 * }
1088 * }
1089 * }
1090 * case application-data {
1091 * container application-data {
1092 * leaf address {
1093 * type simple-address;
1094 * }
1095 * leaf protocol {
1096 * type uint8;
1097 * }
1098 * leaf ip-tos {
1099 * type int32;
1100 * }
1101 * leaf local-port-low {
1102 * type port-number;
1103 * }
1104 * leaf local-port-high {
1105 * type port-number;
1106 * }
1107 * leaf remote-port-low {
1108 * type port-number;
1109 * }
1110 * leaf remote-port-high {
1111 * type port-number;
1112 * }
1113 * }
1114 * }
1115 * case as-number {
1116 * leaf as-number {
1117 * type as-number;
1118 * }
1119 * }
1120 * case as-number-lcaf {
1121 * container as-number-lcaf {
1122 * leaf as {
1123 * type as-number;
1124 * }
1125 * leaf address {
1126 * type simple-address;
1127 * }
1128 * }
1129 * }
1130 * case distinguished-name {
1131 * leaf distinguished-name {
1132 * type distinguished-name-type;
1133 * }
1134 * }
1135 * case explicit-locator-path {
1136 * container explicit-locator-path {
1137 * list hop {
1138 * key "hop-id"
1139 * leaf hop-id {
1140 * type string;
1141 * }
1142 * leaf address {
1143 * type simple-address;
1144 * }
1145 * leaf lrs-bits {
1146 * type bits;
1147 * }
1148 * }
1149 * }
1150 * }
1151 * case geo-coordinates {
1152 * container geo-coordinates {
1153 * leaf latitude {
1154 * type bits;
1155 * }
1156 * leaf latitude-degrees {
1157 * type uint8;
1158 * }
1159 * leaf latitude-minutes {
1160 * type uint8;
1161 * }
1162 * leaf latitude-seconds {
1163 * type uint8;
1164 * }
1165 * leaf longitude {
1166 * type bits;
1167 * }
1168 * leaf longitude-degrees {
1169 * type uint16;
1170 * }
1171 * leaf longitude-minutes {
1172 * type uint8;
1173 * }
1174 * leaf longitude-seconds {
1175 * type uint8;
1176 * }
1177 * leaf altitude {
1178 * type int32;
1179 * }
1180 * leaf address {
1181 * type simple-address;
1182 * }
1183 * }
1184 * }
1185 * case instance-id {
1186 * container instance-id {
1187 * leaf iid {
1188 * type instance-id-type;
1189 * }
1190 * leaf mask-length {
1191 * type uint8;
1192 * }
1193 * leaf address {
1194 * type simple-address;
1195 * }
1196 * }
1197 * }
1198 * case ipv4 {
1199 * leaf ipv4 {
1200 * type ipv4-address;
1201 * }
1202 * }
1203 * case ipv4-binary {
1204 * leaf ipv4-binary {
1205 * type ipv4-address-binary;
1206 * }
1207 * }
1208 * case ipv4-prefix {
1209 * leaf ipv4-prefix {
1210 * type ipv4-prefix;
1211 * }
1212 * }
1213 * case ipv4-prefix-binary {
1214 * leaf ipv4-address-binary {
1215 * type ipv4-address-binary;
1216 * }
1217 * leaf ipv4-mask-length {
1218 * type uint8;
1219 * }
1220 * }
1221 * case ipv6 {
1222 * leaf ipv6 {
1223 * type ipv6-address;
1224 * }
1225 * }
1226 * case ipv6-binary {
1227 * leaf ipv6-binary {
1228 * type ipv6-address-binary;
1229 * }
1230 * }
1231 * case ipv6-prefix {
1232 * leaf ipv6-prefix {
1233 * type ipv6-prefix;
1234 * }
1235 * }
1236 * case ipv6-prefix-binary {
1237 * leaf ipv6-address-binary {
1238 * type ipv6-address-binary;
1239 * }
1240 * leaf ipv6-mask-length {
1241 * type uint8;
1242 * }
1243 * }
1244 * case key-value-address {
1245 * container key-value-address {
1246 * leaf key {
1247 * type simple-address;
1248 * }
1249 * leaf value {
1250 * type simple-address;
1251 * }
1252 * }
1253 * }
1254 * case mac {
1255 * leaf mac {
1256 * type mac-address;
1257 * }
1258 * }
1259 * case nat-traversal {
1260 * container nat-traversal {
1261 * leaf ms-udp-port {
1262 * type uint16;
1263 * }
1264 * leaf etr-udp-port {
1265 * type uint16;
1266 * }
1267 * leaf global-etr-rloc {
1268 * type simple-address;
1269 * }
1270 * leaf ms-rloc {
1271 * type simple-address;
1272 * }
1273 * leaf private-etr-rloc {
1274 * type simple-address;
1275 * }
1276 * leaf-list rtr-rlocs {
1277 * type simple-address;
1278 * }
1279 * }
1280 * }
1281 * case no-address {
1282 * leaf no-address {
1283 * type empty;
1284 * }
1285 * }
1286 * case null-address {
1287 * container null-address {
1288 * leaf address {
1289 * type empty;
1290 * }
1291 * }
1292 * }
1293 * case service-path {
1294 * container service-path {
1295 * leaf service-path-id {
1296 * type service-path-id-type;
1297 * }
1298 * leaf service-index {
1299 * type uint8;
1300 * }
1301 * }
1302 * }
1303 * case source-dest-key {
1304 * container source-dest-key {
1305 * leaf source {
1306 * type simple-address;
1307 * }
1308 * leaf dest {
1309 * type simple-address;
1310 * }
1311 * }
1312 * }
1313 * }
1314 * uses augmented-lisp-address;
1315 * }
1316 * uses eid-container;
1317 * }
1318 * uses MapRequest;
1319 * }
1320 * container transport-address {
1321 * leaf ipAddress {
1322 * type ip-address-binary;
1323 * }
1324 * leaf port {
1325 * type port-number;
1326 * }
1327 * }
1328 * uses MapRequestNotification;
1329 * }
1330 * </pre>
1331 * The schema path to identify an instance is
1332 * <i>odl-lisp-proto/xtrRequestMapping</i>
1333 *
1334 * <p>To create instances of this class use {@link org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMappingBuilder}.
1335 * @see org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMappingBuilder
1336 *
1337 */
1338 public interface XtrRequestMapping
1339 extends
1340 DataObject,
1341 Augmentable<org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping>,
1342 MapRequestNotification,
1343 Notification
1344 {
1345
1346
1347
1348 public static final QName QNAME = org.opendaylight.yangtools.yang.common.QName.create("urn:opendaylight:lfm:lisp-proto",
1349 "2015-11-05", "xtrRequestMapping").intern();
1350
1351
1352 }
1353