summary refs log tree commit diff
path: root/Completion/Unix/Command/_tmux
blob: b564c955d966be9801c6c14c5f1d001b15e48976 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
#compdef tmux

# tmux <http://tmux.github.io> completion for zsh <http://zsh.sf.net>.
#
# Configuration:
#
# - On some OSs, the directory for tmux's server sockets may not be
#   the default (which is /tmp/tmux-<uid>/), but say
#   /var/run/tmux/tmux-<uid>, in which case the completion for
#   'tmux -L <tab>' will not be able to find the sockets in the default
#   location (debian does this, for instance); tell _tmux the right place
#   to look:
#       % zstyle ':completion:*:*:tmux:*:sockets' socketdir "/var/run/tmux/tmux-${UID}"
#
# - tmux knows a *lot* of sub-commands, hence 'tmux <tab>' returns a lot
#   of possible completions. _tmux knows about all commands and their aliases.
#   By default, both are offered. If you do not care about the aliases, do this:
#       % zstyle ':completion:*:*:tmux:*:subcommands' mode 'commands'
#
#   The same can be done to only return aliases by setting the above style
#   to 'aliases'. The default value is 'both' (but actually every value
#   different from 'commands' and 'aliases' will have the same effect).
#
#   'lsw' is an alias for 'list-windows' for example; note that not all
#   commands have aliases. So probably, either the default 'both' or
#   'commands' makes most sense for this style.
#
# - For finer grained control over what is suggested as possible completions,
#   the 'ignored-patterns' style may be used; suppose you think that only
#   '*-window' or '*-windows' are worth being completed. You would get that
#   behaviour like this:
#       % zstyle ':completion:*:*:tmux:*:subcommands' ignored-patterns '^*-window(|s)'
#
#   Some tmux commands currently do not work if called from a shell prompt,
#   so it would make sense to ignore them per default (at the time of writing,
#   those commands are choose-{session,client,window}, confirm-before and
#   find-window. This would ignore them:
#       % zstyle ':completion:*:*:tmux:*:subcommands' ignored-patterns \
#                'choose-*' 'confirm-before' 'find-window'
#
# The configuration for subcommand completions may be done in
# this context: ':completion:*:*:tmux-<sub-command>:*:*'
#
# TODO:
#
#   - Implement __tmux-style (possibly using existing helpers like
#     __tmux-attributes and __tmux-colours)
#   - in _tmux-list-panes, use __tmux-windows or __tmux-sessions
#     depending on -s is among the sub-commands current command line.

# Global variables; setup the first time _tmux is called.
# For $_tmux_commands[] generation, see the very end of this file.
typeset -ga _tmux_commands=() _tmux_aliases=()
typeset -gA _tmux_aliasmap

_tmux_aliasmap=(
    # clients and sessions
    attach      attach-session
    detach      detach-client
    has         has-session
    lockc       lock-client
    locks       lock-session
    lsc         list-clients
    lscm        list-commands
    ls          list-sessions
    new         new-session
    refresh     refresh-client
    rename      rename-session
    showmsgs    show-messages
    source      source-file
    start       start-server
    suspendc    suspend-client
    switchc     switch-client

    # windows and panes
    breakp      break-pane
    capturep    capture-pane
    displayp    display-panes
    findw       find-window
    joinp       join-pane
    killp       kill-pane
    killw       kill-window
    last        last-window
    lastp       last-pane
    linkw       link-window
    lsp         list-panes
    lsw         list-windows
    movep       move-pane
    movew       move-window
    neww        new-window
    nextl       next-layout
    next        next-window
    pipep       pipe-pane
    prev        previous-window
    prevl       previous-layout
    renamew     rename-window
    resizep     resize-pane
    resizew     resize-window
    respawnp    respawn-pane
    respawnw    respawn-window
    rotatew     rotate-window
    selectl     select-layout
    selectp     select-pane
    selectw     select-window
    splitw      split-window
    swapp       swap-pane
    swapw       swap-window
    unlinkw     unlink-window

    # key bindings
    bind        bind-key
    lsk         list-keys
    send        send-keys
    unbind      unbind-key

    # options
    set         set-option
    setw        set-window-option
    show        show-options
    showw       show-window-options

    # environment
    setenv      set-environment
    showenv     show-environment

    # status line
    confirm     confirm-before
    display     display-message

    # buffers
    clearhist   clear-history
    deleteb     delete-buffer
    lsb         list-buffers
    loadb       load-buffer
    pasteb      paste-buffer
    saveb       save-buffer
    setb        set-buffer
    showb       show-buffer

    # miscellaneous
    if          if-shell
    lock        lock-server
    run         run-shell
    info        server-info
    wait        wait-for
)

# --- Sub-command functions ---
# These *must* be called _tmux-*(); The description generation relies on
# them being named that way. *No* other functions may match that pattern.
# Other utility functions should be named __tmux-*() (see below).
#
# Another thing, the description generation needs, is handling of
# $tmux_describe: If that parameter is non-empty, the sub-command function
# should only print a description of the sub-command it handles and return
# immediately after doing so.
#
# To add support for a new sub-command, you only have to add a new
# _tmux-<foo>() function below (preferably alphabetically sorted), that
# behaves like described above; and add a alias->command pair in the
# _tmux_aliasmap associative array above (if the command in fact has an
# alias). The rest should just work[tm].

_tmux-attach-session() {
  [[ -n ${tmux_describe} ]] && print "attach or switch to a session" && return

  _arguments -s \
    '-c+[specify working directory for the session]:directory:_directories' \
    '-d[detach other clients attached to target session]' \
    '-r[put the client into read-only mode]' \
    '-t+[specify target session]:target session: __tmux-sessions-separately' \
    "-E[don't apply update-environment option]"
}

_tmux-bind-key() {
  [[ -n ${tmux_describe} ]] && print "bind a key to a command" && return
  _arguments -s -A "-*" \
    '-c[bind to command mode instead of normal mode]' \
    '-n[make the binding work without the need for the prefix key]' \
    '-r[the key may repeat]' \
    '-T+[specify key table for the binding]:key table' \
    '1:key' \
    '*:::template:= _tmux'
}

_tmux-break-pane() {
  [[ -n ${tmux_describe} ]] && print "break a pane from an existing into a new window" && return
  _arguments -s \
    "-d[don't make the new window become the active one]" \
    '-F+[specify output format]:format:__tmux-formats' \
    '-P[print information of new window after it has been created]' \
    '-n+[specify window name]:name' \
    '-s+[specify source pane]:pane:__tmux-panes' \
    '-t+[specify destination window]:pane:__tmux-panes'
}

_tmux-capture-pane() {
  [[ -n ${tmux_describe} ]] && print "capture the contents of a pane to a buffer" && return
  _arguments -s \
    '-a[use alternate screen]' \
    '(-p)-b+[choose target buffer]:target buffer:__tmux-buffers' \
    '-C[escape non-printable characters as octal \\ooo]' \
    '-e[include escape sequences for attributes etc]' \
    '-E[specify last line to capture]:line number (- means last line)' \
    '-J[join wrapped lines and preserve trailing space]' \
    '-q[ignore errors when trying to access alternate screen]' \
    '(-b)-p[print data to stdout]' \
    '-P[only capture beginnings of as-yet incomplete escape sequences]' \
    '-S[specify start line to capture]:first line (- means start of scrollback)' \
    '-t+[choose source pane]:source pane:__tmux-panes'
}

_tmux-choose-buffer() {
  [[ -n ${tmux_describe} ]] && print "put a pane into buffer choice mode" && return
  _arguments -s \
    '-N[start without the preview]' \
    '-F+[specify format for each list item]:format:__tmux-formats' \
    '-f+[filter items]:filter format:__tmux-formats' \
    '-O+[initial sort order]:order:(time name size)' \
    '-t+[specify target window]:session:__tmux-windows' \
    '*:::template:= _tmux'
}

_tmux-choose-client() {
  [[ -n ${tmux_describe} ]] && print "put a window into client choice mode" && return
  _arguments -s \
    '-N[start without the preview]' \
    '-F+[specify format for each list item]:format:__tmux-formats' \
    '-f+[filter items]:filter format:__tmux-formats' \
    '-O+[initial sort order]:order:(time name size)' \
    '-t+[specify target window]:session:__tmux-windows' \
    '*:::template:= _tmux'
}

_tmux-choose-tree() {
  [[ -n ${tmux_describe} ]] && print "put a window into tree choice mode" && return
  _arguments -s \
    '-G[include all sessions in any session groups in the tree rather than only the first]' \
    '-N[start without the preview]' \
    '-F+[specify format for each list item]:format:__tmux-formats' \
    '-f+[filter items]:filter format:__tmux-formats' \
    '-O+[initial sort order]:order:(time name size)' \
    '-s[choose among sessions]' \
    '-t+[specify target window]:session:__tmux-windows' \
    '-w[choose among windows]' \
    '*:::template:= _tmux'
}

_tmux-clear-history() {
  [[ -n ${tmux_describe} ]] && print "remove and clear history for a pane" && return
  _arguments '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-clock-mode() {
  [[ -n ${tmux_describe} ]] && print "enter clock mode" && return
  _arguments '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-command-prompt() {
  [[ -n ${tmux_describe} ]] && print "open the tmux command prompt in a client" && return
  _arguments -s \
    '-1[only accept one key press]' \
    '-N' \
    '-i[execute the command every time the prompt input changes]' \
    '-I+[specify list of initial inputs]:initial-text (comma-separated list)' \
    '-p+[specify list of prompts]:prompts (comma-separated list)' \
    '-t+[specify target client]:client:__tmux-clients' \
    '*:::template:= _tmux'
}

_tmux-confirm-before() {
  [[ -n ${tmux_describe} ]] && print "run a command but ask for confirmation before" && return
  _arguments -s \
    '-p+[specify prompt]:prompt string' \
    '-t+[specify target client]:client:__tmux-clients' \
    '*:::command:= _tmux'
}

_tmux-copy-mode() {
  [[ -n ${tmux_describe} ]] && print "enter copy mode" && return
  _arguments -s \
    '-t+[specify target pane]:pane:__tmux-panes' \
    '-u[scroll up one page]' \
    '-M[begin a mouse drag]'
}

_tmux-delete-buffer() {
  [[ -n ${tmux_describe} ]] && print "delete a paste buffer" && return
  _arguments '-b+[specify target buffer name]:buffer:__tmux-buffers'
}

_tmux-detach-client() {
  [[ -n ${tmux_describe} ]] && print "detach a client from the server" && return
  _arguments -s \
    '-a[kill all clients except for the named by -t]' \
    '-P[send SIGHUP to parent process]' \
    '-E+[run specified shell command to replace the client]:shell command:_cmdstring' \
    '-s+[specify target session and kill its clients]:session:__tmux-sessions-attached' \
    '-t+[specify target client]:client:__tmux-clients'
}

_tmux-display-message() {
  [[ -n ${tmux_describe} ]] && print "display a message in the status line" && return
  _arguments -s -S -A "-*" \
    '(-p -F :)-a[list the format variables and their values]' \
    '-c+[specify target client]:client:__tmux-clients' \
    '(-a)-p[print message to stdout]' \
    '-t+[specify target pane]:pane:__tmux-panes' \
    '(-a)-F+[specify output format]:format:__tmux-formats' \
    '(-a)-v[prints verbose logging as the format is parsed]' \
    ':message'
}

_tmux-display-panes() {
  [[ -n ${tmux_describe} ]] && print "display an indicator for each visible pane" && return
  _arguments -S \
    "-b[don't block other commands until indicator is closed]" \
    '-d+[time to show indicator for]:duration (ms)' \
    '-t+[specify target client]:client:__tmux-clients' \
    '*:::command:= _tmux'
}

_tmux-find-window() {
  [[ -n ${tmux_describe} ]] && print "search for a pattern in windows" && return
  _arguments -s \
    '-C[match visible contents]' \
    '-N[match window name]' \
    '-T[match window title]' \
    '-t+[specify target window]:window:__tmux-windows' \
    '-Z[zoom the pane]' \
    ':window search pattern'
}

_tmux-has-session() {
  [[ -n ${tmux_describe} ]] && print "check and report if a session exists on the server" && return
  _arguments '-t+[specify target session]:session:__tmux-sessions'
}

_tmux-if-shell() {
  [[ -n ${tmux_describe} ]] && print "execute a tmux command if a shell-command succeeded" && return
  local curcontext="$curcontext" state line ret=1
  _arguments -C -s \
    '-b[run shell command in background]' \
    "-F[don't execute shell command but use it as a string-value]" \
    '-t+[specify target pane]:pane:__tmux-panes' \
    '1:shell command:_cmdstring' \
    '2:tmux command (success):->tmuxcmd' \
    '3:tmux command (failure):->tmuxcmd' && ret=0
  if [[ -n $state ]]; then
    compset -q
    _tmux && ret=0
  fi
}

_tmux-join-pane() {
  [[ -n ${tmux_describe} ]] && print "split a pane and move an existing one into the new space" && return
  _arguments -s \
    '-b[join source pane left of or above target pane]' \
    "-d[don't make the new window become the active one]" \
    '-h[split horizontally]' \
    '-v[split vertically]' \
    "-l+[define new pane's size]: :_guard '[0-9]#' 'numeric value'" \
    "-p+[define new pane's size in percent]: :_guard '[0-9]#' 'numeric value'" \
    '-s+[specify source pane]:pane:__tmux-panes' \
    '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-kill-pane() {
  [[ -n ${tmux_describe} ]] && print "destroy a given pane" && return
  _arguments -s \
    '-a[kill all panes except the one specified by -t]' \
    '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-kill-server() {
  [[ -n ${tmux_describe} ]] && print "kill clients, sessions and server" && return
  __tmux-nothing-else
}

_tmux-kill-session() {
  [[ -n ${tmux_describe} ]] && print "destroy a given session" && return
  _arguments -s \
    '-a[kill all session except the one specified by -t]' \
    '-t+[specify target session]:session:__tmux-sessions' \
    '-C[clear alerts (bell, activity, silence) in all windows linked to the session]'
}

_tmux-kill-window() {
  [[ -n ${tmux_describe} ]] && print "destroy a given window" && return
  _arguments -s \
    '-a[kill all windows except the one specified by -t]' \
    '-t+[specify target window]:window:__tmux-windows'
}

_tmux-last-pane() {
  [[ -n ${tmux_describe} ]] && print "select the previously selected pane" && return
  _arguments -s \
    '-d[disable input to the pane]' \
    '-e[enable input to the pane]' \
    '-t+[specify session]:session:__tmux-sessions'
}

_tmux-last-window() {
  [[ -n ${tmux_describe} ]] && print "select the previously selected window" && return
  _arguments '-t+[specify session]:session:__tmux-sessions'
}

_tmux-link-window() {
  [[ -n ${tmux_describe} ]] && print "link a window to another" && return
  _arguments -s \
    "-d[don't make the new window become the active one]" \
    '-k[kill the target window if it exists]' \
    '-s+[specify source window]:window:__tmux-windows' \
    '-t+[specify destination window]:window:__tmux-windows'
}

_tmux-list-buffers() {
  [[ -n ${tmux_describe} ]] && print "list paste buffers of a session" && return
  _arguments '-F+[specify output format]:format:__tmux-formats'
}

_tmux-list-clients() {
  [[ -n ${tmux_describe} ]] && print "list clients attached to server" && return
  _arguments -s \
    '-F+[specify output format]:format:__tmux-formats' \
    '-t+[specify session]:session:__tmux-sessions'
}

_tmux-list-commands() {
  [[ -n ${tmux_describe} ]] && print "list supported sub-commands" && return
  _arguments '-F+[specify format]:format'
}

_tmux-list-keys() {
  [[ -n ${tmux_describe} ]] && print "list all key-bindings" && return
  _arguments -s \
    '-T+[specify key table]:key table'
}

_tmux-list-panes() {
  [[ -n ${tmux_describe} ]] && print "list panes of a window" && return
  local -a args
  if (( ${+words[(r)-*s*]} )); then
    args=( '-t+[specify target session]:session:__tmux-sessions' )
  else
    args=( '-t+[specify target window]:window:__tmux-windows' )
  fi
  _arguments -s $args \
    '-a[list all panes the server possesses]' \
    '-F+[specify output format]:format:__tmux-formats' \
    '-s[if specified, -t chooses a session]'
}

_tmux-list-sessions() {
  [[ -n ${tmux_describe} ]] && print "list sessions managed by server" && return
  _arguments '-F+[specify output format]:format:__tmux-formats'
}

_tmux-list-windows() {
  [[ -n ${tmux_describe} ]] && print "list windows of a session" && return
  _arguments -s \
    '-a[list all windows the tmux server possesses]' \
    '-F[specify output format]:format:__tmux-formats' \
    '-t+[specify session]:session:__tmux-sessions'
}

_tmux-load-buffer() {
  [[ -n ${tmux_describe} ]] && print "load a file into a paste buffer" && return
  _arguments -A "-*" -S \
    '-b+[specify target buffer name]:buffer:__tmux-buffers' \
    '1:file:_files'
}

_tmux-lock-client() {
  [[ -n ${tmux_describe} ]] && print "lock a client" && return
  _arguments '-t+[specify client]:client:__tmux-clients'
}

_tmux-lock-server() {
  [[ -n ${tmux_describe} ]] && print "lock all clients attached to the server" && return
  __tmux-nothing-else
}

_tmux-lock-session() {
  [[ -n ${tmux_describe} ]] && print "lock all clients attached to a session" && return
  _arguments '-t+[specify session]:session:__tmux-sessions'
}

_tmux-move-pane() {
  [[ -n ${tmux_describe} ]] && print "move a pane into a new space" && return
  _arguments -s \
    '-b[join source pane left of or above target pane]' \
    "-d[don't make the new window become the active one]" \
    '-h[split horizontally]' \
    '-v[split vertically]' \
    "-l+[define new pane's size]:numeric value" \
    "-p+[define new pane's size in percent]:numeric value" \
    '-s+[specify source pane]:pane:__tmux-panes' \
    '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-move-window() {
  [[ -n ${tmux_describe} ]] && print "move a window to another" && return
  _arguments -s \
    "-d[don't make the new window become the active one]" \
    '-k[kill the target window if it exists]' \
    '-s+[specify source window]:window:__tmux-windows' \
    '-r[renumber windows in session in sequential order]' \
    '-t+[specify destination window]:window:__tmux-windows'
}

_tmux-new-session() {
  [[ -n ${tmux_describe} ]] && print "create a new session" && return
  _arguments -s -A "-*" -S \
    '-A[attach to existing session if it already exists]' \
    '-c+[specify working directory for the session]:directory:_directories' \
    "-d[don't attach new session to current terminal]" \
    "-D[in case of -A behave like attach-session's -d]" \
    "-E[don't apply update-environment option]" \
    '-F+[specify output format]:format:__tmux-formats' \
    '-n+[specify initial window name]:window name' \
    '-P[print information about new session after it is created]' \
    '-s+[name the session]:session name:__tmux-sessions' \
    '-t+[specify target session]:session:__tmux-sessions' \
    '-x[specify width]:width' \
    '-y[specify height]:height' \
    '*:: :_cmdambivalent'
}

_tmux-new-window() {
  [[ -n ${tmux_describe} ]] && print "create a new window" && return
  _arguments -s -A "-*" -S \
    '-a[insert new window at next free index from -t]' \
    '-c+[specify working directory for the session]:directory:_directories' \
    "-d[don't make the new window become the active one]" \
    '-F+[specify output format]:format:__tmux-formats' \
    '-k[destroy it if the specified window exists]' \
    '-n+[specify a window name]:window name' \
    '-P[print information about new window after it is created]' \
    '-t+[specify target window]:window:__tmux-windows' \
    '*:: :_cmdambivalent'
}

_tmux-next-layout() {
  [[ -n ${tmux_describe} ]] && print "move a window to the next layout" && return
  _arguments '-t+[specify target window]:window:__tmux-windows'
}

_tmux-next-window() {
  [[ -n ${tmux_describe} ]] && print "move to the next window in a session" && return
  _arguments -s \
    '-a[move to the next window with an alert]' \
    '-t+[specify target session]:session:__tmux-sessions'
}

_tmux-paste-buffer() {
  [[ -n ${tmux_describe} ]] && print "insert a paste buffer into the window" && return
  _arguments -s \
    '-b+[specify buffer]:source buffer:__tmux-buffers' \
    '-d[remove buffer from stack after pasting]' \
    '-p[use bracketed paste mode if the application requested it]' \
    "-r[don't replace LF with CR when pasting]" \
    '-s+[specify separator]:separator' \
    '-t+[specify target window]:window:__tmux-windows'
}

_tmux-pipe-pane() {
  [[ -n ${tmux_describe} ]] && print "pipe output from a pane to a shell command" && return
  _arguments -s -A "-*" -S \
    '-I[write stdout from command to the pane as if it were typed]' \
    '-O[pipe output from the pane to the command (default unless -I used)]' \
    '-o[only open a pipe if none is currently opened]' \
    '-t+[specify target pane]:pane:__tmux-panes' \
    ':shell command:_cmdstring'
}

_tmux-previous-layout() {
  [[ -n ${tmux_describe} ]] && print "move a window to the previous layout" && return
  _arguments '-t+[specify target window]:window:__tmux-windows'
}

_tmux-previous-window() {
  [[ -n ${tmux_describe} ]] && print "move to the previous window in a session" && return
  _arguments -s \
    '-a[move to the previous window with an alert]' \
    '-t+[specify target session]:session:__tmux-sessions'
}

_tmux-refresh-client() {
  [[ -n ${tmux_describe} ]] && print "refresh a client" && return
  _arguments -s -S -A "-*" \
    '-C+[set the width and height of a control client]:width,height' \
    '-c[reset so that the position follows the cursor]' \
    '-D[move visible portion of window down]' \
    '-L[move visible portion of window left]' \
    '-l[request clipboard from the client and store it in a new paste buf using xterm(1) escape sequence]' \
    "-S[only update the client's status bar]" \
    '-t+[specify target client]:client:__tmux-clients' \
    '-R[move visible portion of window right]' \
    '-U[move visible portion of window up]' \
    ': :_guard "[0-9]#" "adjustment"'
}

_tmux-rename-session() {
  [[ -n ${tmux_describe} ]] && print "rename a session" && return
  _arguments -s -A "-*" -S \
    '-t+[specify target session]:session:__tmux-sessions' \
    ':new session name'
}

_tmux-rename-window() {
  [[ -n ${tmux_describe} ]] && print "rename a window" && return
  _arguments -s -A "-*" -S \
    '-t+[specify target window]:window:__tmux-windows' \
    ':new window name'
}

_tmux-resize-pane() {
  [[ -n ${tmux_describe} ]] && print "resize a pane" && return
  _arguments -s -A "-*" -S \
    '-D[resize downward]' \
    '-L[resize to the left]' \
    '-M[begin mouse resizing]' \
    '-R[resize to the right]' \
    '-U[resize upward]' \
    '-t+[specify target pane]:pane:__tmux-panes' \
    '-x+[specify width]:width' \
    '-y+[specify height]:height' \
    '-Z[toggle zoom of pane]' \
    ': :_guard "[0-9]#" "adjustment"'
}

_tmux-resize-window() {
  [[ -n ${tmux_describe} ]] && print "resize a window" && return
  _arguments -s -A "-*" -S : \
    '-A[set size of largest session containing the window]' \
    '-a[set size of smallest session containing the window]' \
    '-D[resize downward]' \
    '-L[resize to the left]' \
    '-R[resize to the right]' \
    '-U[resize upward]' \
    '-t+[specify target pane]:pane:__tmux-windows' \
    '-x+[specify width]:width' \
    '-y+[specify height]:height' \
    ': :_guard "[0-9]#" "adjustment"'
}

_tmux-respawn-pane() {
  [[ -n ${tmux_describe} ]] && print "reuse a pane in which a command has exited" && return
  _arguments -s -A "-*" -S \
    '-c+[specify a new working directory for the pane]:directory:_directories' \
    '-k[kill window if it is in use]' \
    '-t+[specify target pane]:pane:__tmux-pane' \
    ':command:_cmdambivalent'
}

_tmux-respawn-window() {
  [[ -n ${tmux_describe} ]] && print "reuse a window in which a command has exited" && return
  _arguments -s -A "-*" -S \
    '-c+[specify a new working directory for the window]:directory:_directories' \
    '-k[kill window if it is in use]' \
    '-t+[specify target window]:window:__tmux-windows' \
    ':command:_cmdambivalent'
}

_tmux-rotate-window() {
  [[ -n ${tmux_describe} ]] && print "rotate positions of panes in a window" && return
  _arguments -s \
    '-D[rotate downward]' \
    '-U[rotate upward]' \
    '-t+[specify target window]:window:__tmux-windows'
}

_tmux-run-shell() {
  [[ -n ${tmux_describe} ]] && print "execute a command without creating a new window" && return
  _arguments -s -A "-*" -S \
    '-b[run shell command in background]' \
    '-t+[specify target pane]:pane:__tmux-panes' \
    ':command:_cmdstring'
}

_tmux-save-buffer() {
  [[ -n ${tmux_describe} ]] && print "save a paste buffer to a file" && return
  _arguments -s \
    '-a[append to rather than overwriting file]' \
    '-b+[specify a target buffer index]:buffer:__tmux-buffers'
}

_tmux-select-layout() {
  [[ -n ${tmux_describe} ]] && print "choose a layout for a pane" && return
  _arguments -s -A "-*" -S \
    '-E[spread the current pane and any panes next to it out evenly]' \
    '-n[behave like next-layout]' \
    '-o[revert to previous layout]' \
    '-p[behave like previous-layout]' \
    '-t+[specify a target pane]:target pane:__tmux-panes' \
    ':layout:(even-horizontal even-vertical main-horizontal main-vertical tiled)'
}

_tmux-select-pane() {
  [[ -n ${tmux_describe} ]] && print "make a pane the active one in the window" && return
  _arguments -s \
    '-D[move to the pane below target]' \
    '-d[disable input to the pane]' \
    '-e[enable input to the pane]' \
    '-g[show current pane style]' \
    '-l[behave like last-pane]' \
    '-L[move to the pane left of target]' \
    '-M[clear marked pane]' \
    '-m[set marked pane]' \
    '-R[move to the pane right of target]' \
    '-U[move to the pane above target]' \
    '-P+[set pane style]:style:__tmux-style' \
    '-T+[set the pane title]:title' \
    '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-select-window() {
  [[ -n ${tmux_describe} ]] && print "select a window" && return
  _arguments -s \
    '-l[behave like last-window]' \
    '-n[behave like next-window]' \
    '-p[behave like previous-window]' \
    '-T[if selected window is the current behave like last-window]' \
    '-t+[specify target window]:window:__tmux-windows'
}

_tmux-send-keys() {
  [[ -n ${tmux_describe} ]] && print "send key(s) to a window" && return
  _arguments -s -A "-*" -S \
    '-l[disable key name lookup and send data literally]' \
    '-R[reset terminal state]' \
    '-M[pass through a mouse event]' \
    '-X[send a command into copy mode]' \
    '-N+[specify repeat count]:repeat count' \
    '-t+[specify target pane]:pane:__tmux-panes' \
    '*:key'
}

_tmux-send-prefix() {
  [[ -n ${tmux_describe} ]] && print "send the prefix key to a window" && return
  _arguments -s \
    '-2[send secondary prefix key]' \
    '-t+[specify target pane]:pane:__tmux-panes'
}

_tmux-server-info() {
  [[ -n ${tmux_describe} ]] && print "show server information" && return
  __tmux-nothing-else
}

_tmux-set-buffer() {
  [[ -n ${tmux_describe} ]] && print "set contents of a paster buffer" && return
  _arguments -s -A "-*" -S \
    '-a[append to rather than overwriting target buffer]' \
    '-b+[specify target buffer index]:pane:__tmux-buffers' \
    '-n+[specify new buffer name]:buffer-name' \
    ':data'
}

_tmux-set-environment() {
  [[ -n ${tmux_describe} ]] && print "(un)set an environment variable" && return
  local mode=session action=add
  local curcontext="$curcontext" state line ret=1
  typeset -A opt_args
  _arguments -C -s -A "-*" -S : \
    '(-t)-g[modify global environment]' \
    '(-u)-r[remove variable before starting new processes]' \
    '(-r)-u[unset a variable]' \
    '(-g)-t[specify target session]:target session:__tmux-sessions' \
    ': :->name' '(-u -r)2: :->value' && ret=0

  if (( ${+opt_args[-g]} )); then
      mode=global
  fi
  if (( ${+opt_args[-u]} )); then
      action=unset
  fi
  if (( ${+opt_args[-r]} )); then
      action=remove
  fi

  # TODO: the exclusion "(-g -r)2:" doesn't work, so simulate it here
  if [[ $action == (remove|unset) ]] && [[ $state == value ]]; then
      __tmux-nothing-else
  else
      __tmux-environment-variables $mode $state $action && ret=0
  fi
  return ret
}

_tmux-set-option() {
  [[ -n ${tmux_describe} ]] && print "set a session option" && return
  local mode=session
  local curcontext="$curcontext" state line ret=1
  typeset -A opt_args
  _arguments -C -s : \
    '-a[append to string options]' \
    '-F[expand formats in the option value]' \
    '-g[set a global session option]' \
    '-o[prevent setting of an option that is already set]' \
    '-q[suppress errors about unknown or ambiguous options]' \
    '-u[unset a non-global option]' \
    '-w[change window (not session) options]' \
    '-s[change server (not session) options]' \
    '-t+[specify target session]:target session:__tmux-sessions' \
    '*:: :->name_or_value' && ret=0

  if (( ${+opt_args[-w]} )); then
    mode=window
  elif (( ${+opt_args[-s]} )); then
    mode=server
  fi
  __tmux-options-complete ${mode} ${state} && ret=0
  return ret
}

_tmux-set-window-option() {
  [[ -n ${tmux_describe} ]] && print "set a window option" && return
  local curcontext="$curcontext" state line ret=1
  typeset -A opt_args
  _arguments -C -s : \
    '-a[append to string options]' \
    '-F[expand formats in the option value]' \
    '-g[set a global window option]' \
    '-o[prevent setting of an option that is already set]' \
    '-q[suppress errors about unknown or ambiguous options]' \
    '-u[unset a non-global option]' \
    '-t+[specify target window]:target window:__tmux-windows' \
    '*:: :->name_or_value' && ret=0
  __tmux-options-complete window ${state} && ret=0
  return ret
}

_tmux-set-hook() {
  [[ -n ${tmux_describe} ]] && print "set a hook to a command" && return
  _arguments -s \
    '(-R)-g[add hook to global list]' \
    '(-g -u)-R[run hook immediately]' \
    '(-R)-u[unset a hook]' \
    '-t+[specify target session]:session:__tmux-sessions' \
    ':hook name:_tmux_hooks' \
    '*:::command:= _tmux'
}

_tmux-show-hooks() {
  [[ -n ${tmux_describe} ]] && print "show the global list of hooks" && return
  _arguments -s -S -A "-*" \
    '-g[show global list of hooks]' \
    '-t+[specify target session]:session:__tmux-sessions' \
}

_tmux-show-buffer() {
  [[ -n ${tmux_describe} ]] && print "display the contents of a paste buffer" && return
  _arguments '-b[specify target buffer index]:pane:->buffer'
}

_tmux-show-environment() {
  [[ -n ${tmux_describe} ]] && print "display the environment" && return
  local mode=session
  local curcontext="$curcontext" state line ret=1
  typeset -A opt_args
  _arguments -C -A "-*" -s : \
    '(-t)-g[show global environment]' \
    '-s[format output as Bourne shell commands]' \
    '(-g)-t+[specify target session]:target session:__tmux-sessions' \
    '1:: :->name' && ret=0

  if (( ${+opt_args[-g]} )); then
      mode=global
  fi

  __tmux-environment-variables $mode $state show && ret=0
  return ret
}

_tmux-show-messages() {
  [[ -n ${tmux_describe} ]] && print "show client's message log" && return
  _arguments -s \
    '-J[show debugging information about running jobs]' \
    '-T[show debugging information about involved terminals]' \
    '-t+[specify target client]:client:__tmux-clients'
}

_tmux-show-options() {
  [[ -n ${tmux_describe} ]] && print "show session options" && return
  local mode=session
  local curcontext="$curcontext" state line ret=1
  typeset -A opt_args
  _arguments -C -s : \
    '-g[show global options]' \
    '-q[suppress errors about unknown or ambiguous options]' \
    '-s[show server options]' \
    '-v[show only the option value, not the name]' \
    '-w[show window options]' \
    '-t+[specify target session]:target session:__tmux-sessions' \
    '*:: :->name_or_value' && ret=0

  if (( ${+opt_args[-w]} )); then
    mode=window
  elif (( ${+opt_args[-s]} )); then
    mode=server
  fi
  __tmux-options-complete ${mode} ${state} && ret=0
  return ret
}

_tmux-show-window-options() {
  [[ -n ${tmux_describe} ]] && print "show window options" && return
  local curcontext="$curcontext" state line ret=1
  typeset -A opt_args
  _arguments -C -s : \
    '-g[show global options]' \
    '-v[show only the option value, not the name]' \
    '-t+[specify target window]:target window:__tmux-windows' \
    '*:: :->name_or_value' && ret=0
  __tmux-options-complete window ${state} && ret=0
  return ret
}

_tmux-source-file() {
  [[ -n ${tmux_describe} ]] && print "execute tmux commands from a file" && return
  _arguments \
    "-q[don't report error if path doesn't exist]" \
    '*:path:_directories'
}

_tmux-split-window() {
  [[ -n ${tmux_describe} ]] && print "splits a pane into two" && return
  _arguments -s \
    '-b[create new pane left of or above target pane]' \
    "-d[don't make the new window become the active one]" \
    '-F+[specify output format]:format:__tmux-formats' \
    '-f[create new pane spanning full window width or height]' \
    '-h[split horizontally]' \
    '-v[split vertically]' \
    "-l[define new pane's size]:size" \
    "-p[define new pane's size in percent]:size (percentage)" \
    '-t+[specify target pane]:pane:__tmux-panes' \
    ':command:_cmdambivalent'
  # Yes, __tmux-panes is correct here. The behaviour was changed
  # in recent tmux versions and makes more sense. Except that
  # changing the command's name might annoy users. So it stays like
  # this.
}

_tmux-start-server() {
  [[ -n ${tmux_describe} ]] && print "start a tmux server" && return
  __tmux-nothing-else
}

_tmux-suspend-client() {
  [[ -n ${tmux_describe} ]] && print "suspend a client" && return
  _arguments '-t+[specify destination client]:client:__tmux-clients'
}

_tmux-swap-pane() {
  [[ -n ${tmux_describe} ]] && print "swap two panes" && return
  _arguments -s \
    '-D[move pane down]' \
    '-U[move pane up]' \
    "-d[don't change the active pane]" \
    '-s+[specify source pane]:pane:__tmux-panes' \
    '-t+[specify destination pane]:pane:__tmux-panes'
}

_tmux-swap-window() {
  [[ -n ${tmux_describe} ]] && print "swap two windows" && return
  _arguments -s \
    "-d[don't make the new window become the active one]" \
    '-s+[specify source window]:window:__tmux-windows' \
    '-t+[specify destination window]:window:__tmux-windows'
}

_tmux-switch-client() {
  [[ -n ${tmux_describe} ]] && print "switch the client to another session" && return
  _arguments -s \
    '-c+[specify a target client]:client:__tmux-clients' \
    "-E[don't apply update-environment option]" \
    '-l[move client to last session]' \
    '-n[move client to next session]' \
    '-p[move client to previous session]' \
    '-r[toggle read-only flag of client]' \
    '-t+[specify target window]:window:__tmux-windows'
}

_tmux-unbind-key() {
  [[ -n ${tmux_describe} ]] && print "unbind a key" && return
  local curcontext="$curcontext" state line keytable
  local -a ow

  ow=( "${words[@]}" )
  _arguments -C -s \
    '-a[remove all key bindings]' \
    '-n[remove a non-prefix binding]' \
    '-T[specify key table]:key table' \
    '*:: :->boundkeys'

    [[ ${state} != 'boundkeys' ]] && return
    keytable="$(__tmux-get-optarg -t "${ow[@]}")"
    if [[ -n ${keytable} ]]; then
        __tmux-bound-keys -t ${keytable}
        return
    fi
    __tmux-bound-keys
}

_tmux-unlink-window() {
  [[ -n ${tmux_describe} ]] && print "unlink a window" && return
  _arguments -s \
    '-k[kill the window if it is only in one session]' \
    '-t+[specify target window]:target window:__tmux-windows'
}

_tmux-wait-for() {
  [[ -n ${tmux_describe} ]] && print "wait for an event or trigger it" && return
  _arguments -s \
    '-L[lock the named channel]' \
    '-S[send signal to channel]' \
    '-U[unlock the named channel]' \
    ':event channel'
}

# --- Utility functions ---
# They should be called __tmux-*() and kept separate from the
# sub-command functions.

function __tmux-attributes() {
    local -a attr already
    attr=( default bright bold dim underscore blink reverse hidden italics )
    compset -P '*,'
    already=( ${(s<,>)IPREFIX} )
    _describe -t tmux-attribute 'tmux attribute' attr -S, -F already -q
}

function __tmux-buffers() {
    local expl
    local -a buffers

    if [[ ${(t)bopts} != *array* ]]; then
        local -a bopts; bopts=()
    fi

    buffers=( ${${(f)"$(command tmux 2> /dev/null list-buffers "${bopts[@]}")"}/:[ $'\t']##/:} )
    _describe -t buffers 'buffers' buffers
}

function __tmux-bound-keys() {
    local expl
    local -a keys

    keys=( ${${${${(f)"$(command tmux 2> /dev/null list-keys "$@")"}/:[ $'\t']##/:}/(#s)[ $'\t']##/}/(#s):/\\:} )
    _describe -t keys 'keys' keys
}

function __tmux-clients() {
    local expl
    local -a clients
    clients=( ${${(f)"$(command tmux 2> /dev/null list-clients)"}/:[ $'\t']##/:} )
    _describe -t clients 'clients' clients
}

function __tmux-environment-variables() {
    local mode="$1" state="$2" action="$3"

    local -a dash_g
    case $mode in
        (global) dash_g=(-g);;
        (session) dash_g=();;
        (*) return 1;; # bug in the caller
    esac

    local hint
    case $action in
        (add|remove) hint=" (or specify a new one)";;
        (unset|show) hint="";;
        (*) return 1;; # bug in the caller
    esac

    case ${state} in
        (name) 
            local -a vars_and_vals=( ${(@f)"$(command tmux 2>/dev/null show-env $dash_g)"} )
            local -a descriptions
            local k_v k v
            for k_v in $vars_and_vals; do
                k=${k_v%%=*}
                if [[ $k == -* ]]; then
                    k=${k#-}
                    v='(remove)'
                else
                    v=${k_v#*=}
                fi
                descriptions+=( "${k//:/\\:}:$v" )
            done
            # TODO: this if/else is because '_describe ${hint:+"-x"}' prints the "No matches" error in addition to the message.
            local msg="${dash_g[1]:+"global "}environment variables${hint}"
            if _describe -t parameters $msg descriptions; then
                :
            elif [[ -n $hint ]]; then
                _message -e $msg
            fi
            ;;
        (value)
            local var_and_val=${(@f)"$(command tmux 2>/dev/null show-env $dash_g -- ${(Q)words[-2]})"}
            # TODO: this if/else is because '_description -x' prints the "No matches" error in addition to the message.
            if [[ -n $var_and_val ]]; then
                local -a expl
                _description -x parameter-values expl "value for ${words[-2]}"
                compadd "$expl[@]" - ${var_and_val#*=}
            else
                _message -e "value for ${words[-2]}"
            fi
            ;;
        (*)
            return 1
            ;;
    esac
}

__tmux-formats() {
  local hash='#' open='{' close='}' paren='(' quest='?'
  local tmux_variables expl
  compquote hash open close paren quest
  compset -p ${#PREFIX%$hash*}
  if compset -P "${(q)hash}${open}"; then
    if compset -P "${(q)quest}"; then
      close=,
    elif ! compset -P "([bdt]|s/[^/]#/[^/]#/|=(-|)<->):"; then
      _describe -t operators operator '(
	\?:conditional
	\=:length\ limit
      )' -S '' -- '(
	m:fnmatch\ comparison
	t:convert\ time\ to\ string
	b:basename
	c:search\ for\ fnmatch\ pattern\ in\ pane\ content
	d:dirname
	\==:comparison
	\!=:comparison
      )' -S : -- '(
	s:substitution
      )' -S / -- '(
	\|\|:either\ of\ two\ conditions
	\&\&:both\ of\ two\ conditions
      )' -S ,
    fi
    tmux_variables=(
      'alternate_on:if pane is in alternate screen'
      'alternate_saved_x:saved cursor X in alternate screen'
      'alternate_saved_y:saved cursor Y in alternate screen'
      'buffer_created:time buffer created'
      'buffer_name:name of buffer'
      'buffer_sample:sample of start of buffer'
      'buffer_size:size of the specified buffer in bytes'
      'client_activity:time client last had activity'
      'client_created:time client created'
      'client_control_mode:1 if client is in control mode'
      'client_discarded:bytes discarded when client behind'
      'client_height:height of client'
      'client_key_table:current key table'
      "client_last_session:name of the client's last session"
      'client_name:name of client'
      'client_pid:PID of client process'
      'client_prefix:1 if prefix key has been pressed'
      'client_readonly:1 if client is readonly'
      "client_session:name of the client's session"
      'client_termname:terminal name of client'
      'client_termtype:terminal type of client'
      'client_tty:pseudo terminal of client'
      'client_utf8:1 if client supports utf8'
      'client_width:width of client'
      'client_written:bytes written to client'
      'command:name of command in use, if any'
      'command_list_name:command name if listing commands'
      'command_list_alias:command alias if listing commands'
      'command_list_usage:command usage if listing commands'
      'cursor_flag:pane cursor flag'
      'cursor_character:character at cursor in pane'
      'cursor_x:cursor X position in pane'
      'cursor_y:cursor Y position in pane'
      'history_bytes:number of bytes in window history'
      'history_limit:maximum window history lines'
      'history_size:size of history in lines'
      'hook:name of running hook, if any'
      'hook_pane:ID of pane where hook was run, if any'
      'hook_session:ID of session where hook was run, if any'
      'hook_session_name:name of session where hook was run, if any'
      'hook_window:ID of window where hook was run, if any'
      'hook_window_name:name of window where hook was run, if any'
      'host:hostname of local host'
      'host_short:hostname of local host (no domain name)'
      'insert_flag:pane insert flag'
      'keypad_cursor_flag:pane keypad cursor flag'
      'keypad_flag:pane keypad flag'
      'line:line number in the list'
      'mouse_any_flag:pane mouse any flag'
      'mouse_button_flag:pane mouse button flag'
      'mouse_standard_flag:pane mouse standard flag'
      'mouse_all_flag:pane mouse all flag'
      'pane_active:1 if active pane'
      'pane_at_bottom:1 if pane is at the bottom of window'
      'pane_at_left:1 if pane is at the left of window'
      'pane_at_right:1 if pane is at the right of window'
      'pane_at_top:1 if pane is at the top of window'
      'pane_bottom:bottom of pane'
      'pane_current_command:current command if available'
      'pane_dead:1 if pane is dead'
      'pane_dead_status:exit status of process in dead pane'
      'pane_format:1 if format is for a pane (not assuming the current)'
      'pane_height:height of pane'
      'pane_id:unique pane ID'
      'pane_in_mode:if pane is in a mode'
      'pane_input_off:if input to pane is disabled'
      'pane_index:index of pane'
      'pane_left:left of pane'
      'pane_mode:name of pane mode, if any.'
      'pane_pid:PID of first process in pane'
      'pane_pipe:1 if pane is being piped'
      'pane_right:right of pane'
      'pane_search_string:last search string in copy mode'
      'pane_start_command:command pane started with'
      'pane_synchronized:if pane is synchronized'
      'pane_tabs:pane tab positions'
      'pane_title:title of pane'
      'pane_top:top of pane'
      'pane_tty:pseudo terminal of pane'
      'pane_width:width of pane'
      'pid:server PID'
      'rectangle_toggle:1 if rectangle selection is activated'
      'scroll_region_lower:bottom of scroll region in pane'
      'scroll_region_upper:top of scroll region in pane'
      'scroll_position:scroll position in copy mode'
      'selection_present:1 if selection started in copy mode'
      'session_alerts:list of window indexes with alerts'
      'session_attached:number of clients session is attached to'
      'session_activity:time of session last activity'
      'session_created:time session created'
      'session_format:1 if format is for a session (not assuming the current)'
      'session_last_attached:time session last attached'
      'session_group:name of session group'
      'session_group_size:size of session group'
      'session_group_list:list of sessions in group'
      'session_grouped:1 if session in a group'
      'session_id:unique session ID'
      'session_many_attached:1 if multiple clients attached'
      'session_name:name of session'
      'session_stack:window indexes in most recent order'
      'session_width:width of session'
      'session_windows:number of windows in session'
      'socket_path:server socket path'
      'start_time:server start time'
      'version:server version'
      'window_activity:time of window last activity'
      'window_activity_flag:1 if window has activity'
      'window_active:1 if window active'
      'window_bell_flag:1 if window has bell'
      'window_flags:window flags'
      'window_format:1 if format is for a window (not assuming the current)'
      'window_height:height of window'
      'window_id:unique window ID'
      'window_index:index of window'
      'window_last_flag:1 if window is the last used'
      'window_layout:window layout description, ignoring zoomed window panes'
      'window_linked:1 if window is linked across sessions'
      'window_name:name of window'
      'window_offset_x:X offset into window if larger than client'
      'window_offset_y:Y offset into window if larger than client'
      'window_panes:number of panes in window'
      'window_silence_flag:1 if window has silence alert'
      'window_stack_index:index in session most recent stack'
      'window_visible_layout:window layout description, respecting zoomed window panes'
      'window_width:width of window'
      'window_zoomed_flag:1 if window is zoomed'
      'wrap_flag:pane wrap flag'
    )
    _describe -t variables variable tmux_variables -S "$close"
  elif compset -P "${(q)hash}${(q)paren}"; then
    compset -S '(\\|)\)*'
    _cmdstring
  elif [[ $PREFIX = ${hash}* ]]; then
    _describe -t variables variable '(
      \#H:local\ hostname
      \#h:short\ local\ hostname
      \#D:pane\ id
      \#P:pane\ index
      \#T:pane\ title
      \#S:session\ name
      \#F:window\ flags
      \#I:window\ index
      \#W:window\ name
    )' -S ''
  else
    _wanted format-specifiers expl 'format specifier' compadd -S '' \#
  fi
}

function __tmux-colours() {
    local -a colnames
    colnames=( default black red green yellow blue magenta cyan white colourN:"replace N by a number between 0 and 255" )
    compset -P 'colour*'
    if [[ -z ${IPREFIX} ]]; then
        _describe -t tmux-colours 'colour' colnames
    else
        _message 'colour number 0..255'
    fi
}

_tmux_hooks() {
  _alternative \
    'hooks:hook name:(alert-activity alert-bell alert-silence client-attached client-detached client-resized client-session-changed pane-died pane-exited pane-set-clipboard session-created session-closed session-renamed window-linked window-renamed window-unlinked)' \
    'post-hooks:command post-hook:compadd - after-${_tmux_aliasmap}'
}

function __tmux-get-optarg() {
    local opt="$1"
    local -i i
    shift

    for (( i = 1; i <= $#; i++ )); do
        if [[ ${argv[$i]} == ${opt} ]]; then
            if [[ ${argv[$(( i + 1 ))]} != -* ]]; then
                print -- ${argv[$(( i + 1 ))]}
            fi
            return
        fi
    done
}

__tmux-nothing-else() {
  _message -e "no further arguments"
}

function __tmux-option-guard() {
    local mode opt guard int_guard
    mode="$1"
    opt="$2"
    shift; shift
    local -a options desc
    int_guard='_guard "[0-9]#" "'${opt}': numeric value"'
    if [[ ${mode} == 'session' ]]; then
        options=(
            'activity-action:DESC:any none current other'
            'assume-paste-time:'${int_guard}
            'base-index:'${int_guard}
            'bell-action:DESC:any none current other'
            'default-command:MSG:command string'
            'default-shell:MSG:shell executable'
            'default-size:MSG:XxY'
            'destroy-unattached:DESC:on off'
            'detach-on-destroy:DESC:on off'
            'display-panes-colour:__tmux-colours'
            'display-panes-active-colour:__tmux-colours'
            'display-panes-time:'${int_guard}
            'display-time:'${int_guard}
            'history-limit:'${int_guard}
            'lock-after-time:'${int_guard}
            'lock-command:MSG:command string'
            'message-command-style:__tmux-style'
            'message-style:__tmux-style'
            'mouse:DESC:on off'
            'prefix:MSG:primary prefix key'
            'prefix2:MSG:secondary prefix key'
            'renumber-windows:DESC:on off'
            'repeat-time:'${int_guard}
            'set-titles:DESC:on off'
            'set-titles-string:MSG:title format string'
            'silence-action:DESC:any none current other'
            'status:DESC:on off'
            'status-format:MSG:format string'
            'status-interval:'${int_guard}
            'status-justify:DESC:left centre right'
            'status-keys:DESC:vi emacs'
            'status-left:MSG:format string'
            'status-left-length:'${int_guard}
            'status-left-style:__tmux-style'
            'status-position:DESC:top bottom'
            'status-right:MSG:format string'
            'status-right-length:'${int_guard}
            'status-right-style:__tmux-style'
            'status-style:__tmux-style'
            'update-environment:MSG:string listing env. variables'
            'user-keys:MSG:key'
            'visual-activity:DESC:on off'
            'visual-bell:DESC:on off'
            'visual-silence:DESC:on off'
            'word-separators:MSG:separator string'
        )
    elif [[ ${mode} == 'server' ]]; then
        options=(
            'buffer-limit:'${int_guard}
            'command-alias:MSG:alias'
            'default-terminal:MSG:terminal string'
            'escape-time:'${int_guard}
            'exit-empty:DESC:on off'
            'exit-unattached:DESC:on off'
            'focus-events:DESC:on off'
            'history-file:_path-files -g "*(-.)"'
            'message-limit:'${int_guard}
            'set-clipboard:DESC:on off'
            'terminal-overrides:MSG:overrides string'
        )
    else
        options=(
            'aggressive-resize:DESC:on off'
            'allow-rename:DESC:on off'
            'alternate-screen:DESC:on off'
            'automatic-rename:DESC:on off'
            'automatic-rename-format:DESC:__tmux-format'
            'clock-mode-colour:__tmux-colours'
            'clock-mode-style:DESC:12 24'
            'main-pane-height:'${int_guard}
            'main-pane-width:'${int_guard}
            'mode-keys:DESC:vi emacs'
            'mode-style:__tmux-style'
            'monitor-activity:DESC:on off'
            'monitor-bell:DESC:on off'
            'monitor-silence:DESC:on off'
            'other-pane-height:'${int_guard}
            'other-pane-width:'${int_guard}
            'pane-active-border-style:__tmux-style'
            'pane-base-index:'${int_guard}
            'pane-border-format:MSG:pane border status string'
            'pane-border-status:DESC:off top bottom'
            'pane-border-style:__tmux-style'
            'remain-on-exit:DESC:on off'
            'synchronize-panes:DESC:on off'
            'window-active-style:__tmux-style'
            'window-status-activity-style:__tmux-style'
            'window-status-bell-style:__tmux-style'
            'window-status-current-format:MSG:status format string'
            'window-status-current-style:__tmux-style'
            'window-status-format:MSG:status format string'
            'window-status-last-style:__tmux-style'
            'window-status-separator:MSG:separator string'
            'window-status-style:__tmux-style'
            'window-size:MSG:XxY'
            'window-style:__tmux-style'
            'wrap-search:DESC:on off'
            'xterm-keys:DESC:on off'
        )
    fi

    guard=${(M)options:#$opt:*}
    if [[ -z ${guard} ]]; then
        _message "unknown ${mode} option: ${opt}"
        return
    fi
    guard=${guard#*:}
    case ${guard} in
        ('') ;;
        (MSG:*)
            _message -e ${guard#*:}
            ;;
        (DESC:*)
            eval "desc=( ${guard#*:} )"
            _describe -t "tmux-${mode}-option-value" "${opt}" desc
            ;;
        (*)
            eval ${guard}
            ;;
    esac
}

function __tmux-session-options() {
    local -a tmux_session_options
    tmux_session_options=(
        'activity-action:set action on window activity when monitor-activity is on'
        'assume-paste-time:assume keys are pasted instead of typed if this fast'
        'base-index:define where to start numbering'
        'bell-action:set action on window bell'
        'default-command:default command for new windows'
        'default-shell:default shell executable'
        'default-size:set the default size of windows when the size is not set'
        'destroy-unattached:destroy session if no client is attached'
        'detach-on-destroy:detach client if attached session is destroyed'
        'display-panes-colour:colour used for display-panes'
        'display-panes-active-colour:colour for active pane in display-panes'
        'display-panes-time:time (in msecs) of display-panes output'
        'display-time:time (in msecs) messages are displayed'
        'history-limit:number of copy-mode lines per window'
        'key-table:default key table'
        'lock-after-time:lock sessions after N seconds'
        'lock-command:command to run for locking a client'
        'message-command-style:status line message command style'
        'message-style:status line message style'
        'mouse:enable mouse support'
        'prefix:primary prefix key'
        'prefix2:secondary prefix key'
        'renumber-windows:renumber windows if a window is closed'
        'repeat-time:time for multiple commands without prefix-key presses'
        'set-titles:try to set xterm window titles'
        'set-titles-string:format used by set-titles'
        'silence-action:set action on window silence when monitor-silence is on'
        'status:show or hide the status bar'
        'status-format:specify the format to be used for each line of the status line'
        'status-interval:interval (in seconds) for status bar updates'
        'status-justify:position of the window list in status bar'
        'status-keys:mode to use in status bar modes (vi/emacs)'
        'status-left:format to use left in status bar'
        'status-left-length:maximum length of the left part of the status bar'
        'status-left-style:style of left part of status line'
        'status-position:status line position'
        'status-right:format to use right in status bar'
        'status-right-length:maximum length of the right part of the status bar'
        'status-right-style:style of right part of status line'
        'status-style:style status line'
        "update-environment:list of variables to be copied to a session's environment"
        'user-keys:set list of user-defined key escape sequences'
        'visual-activity:display status line messages upon activity'
        'visual-bell:use visual bell instead of audible'
        'visual-silence:print a message if monitor-silence is on'
        'word-separators:string of characters considered word separators'
    )
    _describe -t tmux-options 'tmux session option' tmux_session_options
}

function __tmux-options-complete() {
    local mode="$1" state="$2"

    case ${state} in
        name_or_value)
            if (( CURRENT == 1 )) && [[ ${mode} == 'session' ]]; then
                __tmux-session-options
            elif (( CURRENT == 1 )) && [[ ${mode} == 'server' ]]; then
                __tmux-server-options
            elif (( CURRENT == 1 )) && [[ ${mode} == 'window' ]]; then
                __tmux-window-options
            elif (( CURRENT == 2 )); then
                __tmux-option-guard ${mode} ${words[1]}
            else
                __tmux-nothing-else
            fi
            ;;
    esac
}

function __tmux-panes() {
    local expl line
    local -i num
    local -a panes opts

    compset -P '*.'
    if [[ -n ${IPREFIX} ]]; then
        opts=( -t "${IPREFIX%.}" )
    else
        opts=( )
    fi
    num=0
    command tmux 2> /dev/null list-panes "${opts[@]}" | while IFS= read -r line; do
        panes+=( $(( num++ )):${line//:/} )
    done
    _describe -t panes 'panes' panes "$@"
    if [[ ${IPREFIX} != *. ]]; then
        _wanted windows expl 'windows' __tmux-windows -S.
    fi
}

function __tmux-server-options() {
    local -a tmux_server_options
    tmux_server_options=(
        'buffer-limit:number of buffers kept per session'
        'command-alias:custom command aliases'
        'default-terminal:default terminal definition string'
        'escape-time:set timeout to detect single escape characters (in msecs)'
        'exit-unattached:make server exit if it has no attached clients'
        'exit-empty:exit when there are no active sessions'
        'focus-events:request focus events from terminal'
        'history-file:tmux command history file name'
        'message-limit:set size of message log per client'
        'set-clipboard:use esc sequences to set terminal clipboard'
        'terminal-overrides:override terminal descriptions'
    )
    _describe -t tmux-server-options 'tmux server option' tmux_server_options
}

function __tmux-sessions() {
    local -a sessions
    sessions=( ${${(f)"$(command tmux 2> /dev/null list-sessions)"}/:[ $'\t']##/:} )
    _describe -t sessions 'sessions' sessions "$@"
}

function __tmux-sessions-attached() {
    local -a sessions
    sessions=( ${${(f)"$(command tmux 2> /dev/null list-sessions)"}/:[ $'\t']##/:} )
    sessions=( ${(M)sessions:#*"(attached)"} )
    _describe -t sessions 'attached sessions' sessions "$@"
}

# Complete attached-sessions and detached-sessions as separate tags.
function __tmux-sessions-separately() {
    local ret=1
    local -a sessions detached_sessions attached_sessions
    sessions=( ${${(f)"$(command tmux 2> /dev/null list-sessions)"}/:[ $'\t']##/:} )
    detached_sessions=(    ${sessions:#*"(attached)"} )
    attached_sessions=( ${(M)sessions:#*"(attached)"} )

    # ### This seems to work without a _tags loop but not with it.  I suspect
    # ### that has something to do with _describe doing its own _tags loop.
    _tags detached-sessions attached-sessions
    # Placing detached before attached means the default behaviour of this
    # function better suits its only current caller, _tmux-attach-session().
    _requested detached-sessions && _describe -t detached-sessions 'detached sessions' detached_sessions "$@" && ret=0
    _requested attached-sessions && _describe -t attached-sessions 'attached sessions' attached_sessions "$@" && ret=0

    return ret
}

function __tmux-socket-name() {
    local expl sdir
    local curcontext="${curcontext}"
    local -a socks
    zstyle -s ":completion:${curcontext}:sockets" socketdir sdir || sdir="${TMUX_TMPDIR:-/tmp}/tmux-${UID}"
    socks=(${sdir}/*(=:t))
    _wanted socket expl 'socket name' compadd ${expl} -- ${socks}
}

function __tmux-style() {
    _message 'not implemented yet'
}

function __tmux-window-options() {
    local -a tmux_window_options
    tmux_window_options=(
        'aggressive-resize:aggressively resize windows'
        'allow-rename:allow programs to change window titles'
        'alternate-screen:allow alternate screen feature to be used'
        'automatic-rename:attempt to automatically rename windows'
        'automatic-rename-format:format for automatic renames'
        'clock-mode-colour:set clock colour'
        'clock-mode-style:set clock hour format (12/24)'
        'main-pane-height:set height for main-* layouts'
        'main-pane-width:set width for main-* layouts'
        'mode-keys:mode to use in copy and choice modes (vi/emacs)'
        'mode-style:set window modes style'
        'monitor-activity:monitor window activity'
        'monitor-bell:monitor for a bell in the window'
        'monitor-silence:monitor window for inactivity'
        'other-pane-height:height of other panes'
        'other-pane-width:width of other panes'
        'pane-active-border-style:style of border of active pane'
        'pane-base-index:integer at which to start indexing panes'
        'pane-border-format:set pane border format string'
        'pane-border-status:turn border status off or set its position'
        'pane-border-style:style of border pane'
        "remain-on-exit:don't destroy windows after the program exits"
        'synchronize-panes:send input to all panes of a window'
        'window-active-style:style of active window'
        'window-status-activity-style:style of status bar activity tag'
        'window-status-bell-style:style of status bar bell tag'
        'window-status-current-format:set status line format for active window'
        'window-status-current-style:style of current window in status bar'
        'window-status-format:set status line format for all but the active window'
        'window-status-last-style:style of last window in status bar'
        'window-status-separator:separator drawn between windows in status line'
        'window-status-style:general status bar style'
        'window-size:indicate how to automatically size windows'
        'window-style:style of window'
        'wrap-search:search wrap around at the end of a pane'
        'xterm-keys:generate xterm-style function key sequences'
    )
    _describe -t tmux-window-options 'tmux window option' tmux_window_options
}

function __tmux-windows() {
    local expl
    local -a wins opts

    compset -P '*:'
    if [[ -n ${IPREFIX} ]]; then
        opts=( -t "${IPREFIX%:}" )
    else
        opts=( )
    fi
    wins=( ${${(M)${(f)"$(command tmux 2> /dev/null list-windows "${opts[@]}")"}:#<->*}/:[ $'\t']##/:} )
    _describe -t windows 'windows' wins "$@"
    if [[ ${IPREFIX} != *: ]]; then
        _wanted sessions expl 'sessions' __tmux-sessions -S:
    fi
}

# And here is the actual _tmux(), that puts it all together:
_tmux() {
  local curcontext="${curcontext}" state line ret=1
  local mode
  local tmuxcommand
  local tmux_describe

  _arguments -C -s -w \
    '-2[force using 256 colours]' \
    '-c[execute a shell command]:command name:_command_names' \
    '-C[start tmux in control mode. -CC disables echo]' \
    '-f[specify configuration file]:tmux config file:_files -g "*(-.)"' \
    '-l[behave like a login shell]' \
    '-L[specify socket name]:socket name:__tmux-socket-name' \
    '-S[specify socket path]:server socket:_path_files -g "*(=,/)"' \
    '-u[force using UTF-8]' \
    '-v[request verbose logging]' \
    '-V[report tmux version]' \
    '*:: :->subcommand_or_options' && ret=0

  [[ -z $state ]] && return ret

  if (( CURRENT == 1 )); then
    zstyle -s ":completion:${curcontext}:subcommands" mode mode || mode='both'
    if [[ ${mode} == 'commands' ]]; then
      _describe -t subcommands 'tmux commands' _tmux_commands && ret=0
    elif [[ ${mode} == 'aliases' ]]; then
      _describe -t subcommands 'tmux aliases' _tmux_aliases && ret=0
    else
      _describe -t subcommands 'tmux commands and aliases' _tmux_commands -- _tmux_aliases && ret=0
    fi
  else
    tmuxcommand="${words[1]}"
    if [[ -n ${_tmux_aliasmap[$tmuxcommand]} ]] ; then
      tmuxcommand="${_tmux_aliasmap[$tmuxcommand]}"
    fi
    if ! (( ${+functions[_tmux-$tmuxcommand]} )); then
      local low high
      low=$_tmux_commands[(i)$tmuxcommand*]
      high=$_tmux_commands[(I)$tmuxcommand*]
      if (( low == high )); then
	tmuxcommand=${_tmux_commands[low]%%:*}
      elif (( low < high )); then
	_message "ambiguous command $tmuxcommand"
      else
	_message "subcommand $tmuxcommand not known"
	_normal && ret=0
      fi
    fi
    curcontext="${curcontext%:*}-${tmuxcommand}:"
    _call_function ret _tmux-${tmuxcommand}
  fi
  return ret
}

# description generation follows; only done on 1st _tmux call.
local f desc
local -A rev
local tmux_describe
tmux_describe='yes, please'
for f in ${(k)_tmux_aliasmap} ; do
  rev+=( ${_tmux_aliasmap[$f]} $f )
done
for f in ${(M)${(k)functions}:#_tmux-*} ; do
  desc="$($f)"
  _tmux_commands+=( "${f#_tmux-}${desc:+:$desc}" )
  [[ -n ${rev[${f#_tmux-}]} ]] && _tmux_aliases+=( "${rev[${f#_tmux-}]}${desc:+:$desc}" )
done

_tmux "$@"