fork/wezterm

git clone https://git.julia.blue/fork/wezterm

Wez Furlongdocs and missing bit of #4535 #452391749f7f1

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