completers4arguments.ps1

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
$configAll = { Get-Config }

$containerAll = { Get-Container }
$containerRunning = { Get-Container -Status running }

$formatBasic = @("'{{json .}}'")

$logDriver = {
    'awslogs'
    'etwlogs'
    'fluentd'
    'gcplogs'
    'gelf'
    'journald'
    'json-file'
    'logentries'
    'none'
    'splunk'
    'syslog'
}

$networkAll = { Get-Network }

$imageAll = { Get-Image }

$serviceAll = { Get-Service }

$stackAll = { docker stack ls --format '{{.Name}}' }

$volumeAll = { Get-Volume }

$capAddable = {
    COMPGEN ALL string 'All capabilities'
    COMPGEN AUDIT_CONTROL string 'Enable and disable kernel auditing; change auditing filter rules; retrieve auditing status and filtering rules'
    COMPGEN BLOCK_SUSPEND string 'Employ features that can block system suspend'
    COMPGEN DAC_READ_SEARCH string 'Bypass file read permission checks and directory read and execute permission checks'
    COMPGEN IPC_LOCK string 'Lock memory (mlock(2), mlockall(2), mmap(2), shmctl(2))'
    COMPGEN IPC_OWNER string 'Bypass permission checks for operations on System V IPC objects'
    COMPGEN LEASE string 'Establish leases on arbitrary files (see fcntl(2))'
    COMPGEN LINUX_IMMUTABLE string 'Set the FS_APPEND_FL and FS_IMMUTABLE_FL i-node flags'
    COMPGEN MAC_ADMIN string 'Override Mandatory Access Control (MAC). Implemented for the Smack Linux Security Module (LSM)'
    COMPGEN MAC_OVERRIDE string 'Allow MAC configuration or state changes. Implemented for the Smack LSM'
    COMPGEN NET_ADMIN string 'Perform various network-related operations'
    COMPGEN NET_BROADCAST string 'Make socket broadcasts, and listen to multicasts'
    COMPGEN SYS_ADMIN string 'Perform a range of system administration operations'
    COMPGEN SYS_BOOT string 'Use reboot(2) and kexec_load(2), reboot and load a new kernel for later execution'
    COMPGEN SYS_MODULE string 'Load and unload kernel modules'
    COMPGEN SYS_NICE string 'Raise process nice value (nice(2), setpriority(2)) and change the nice value for arbitrary processes'
    COMPGEN SYS_PACCT string 'Use acct(2), switch process accounting on or off'
    COMPGEN SYS_PTRACE string 'Trace arbitrary processes using ptrace(2)'
    COMPGEN SYS_RAWIO string 'Perform I/O port operations (iopl(2) and ioperm(2))'
    COMPGEN SYS_RESOURCE string 'Override resource Limits'
    COMPGEN SYS_TIME string 'Set system clock (settimeofday(2), stime(2), adjtimex(2)); set real-time (hardware) clock'
    COMPGEN SYS_TTY_CONFIG string 'Use vhangup(2); employ various privileged ioctl(2) operations on virtual terminals'
    COMPGEN SYSLOG string 'Perform privileged syslog(2) operations'
    COMPGEN WAKE_ALARM string 'Trigger something that will wake up the system'
}

$capDroppable = {
    COMPGEN ALL string 'All capabilities'
    COMPGEN AUDIT_WRITE string 'Write records to kernel auditing log'
    COMPGEN CHOWN string 'Make arbitrary changes to file UIDs and GIDs (see chown(2))'
    COMPGEN DAC_OVERRIDE string 'Bypass file read, write, and execute permission checks'
    COMPGEN FOWNER string 'Bypass permission checks on operations that normally require the file system UID of the process to match the UID of the file'
    COMPGEN FSETID string 'Don''t clear set-user-ID and set-group-ID permission bits when a file is modified'
    COMPGEN KILL string 'Bypass permission checks for sending signals'
    COMPGEN MKNOD string 'Create special files using mknod(2)'
    COMPGEN NET_BIND_SERVICE string 'Bind a socket to internet domain privileged ports (port numbers less than 1024)'
    COMPGEN NET_RAW string 'Use RAW and PACKET sockets'
    COMPGEN SETFCAP string 'Set file capabilities'
    COMPGEN SETGID string 'Make arbitrary manipulations of process GIDs and supplementary GID list'
    COMPGEN SETPCAP string 'Modify process capabilities'
    COMPGEN SETUID string 'Make arbitrary manipulations of process UIDs'
    COMPGEN SYS_CHROOT string 'Use chroot(2), change root directory'
}

$mount = {
    Param($wordToComplete, $commandAst, $cursorPosition)

    # Get type
    foreach ($keyValue in ($commandAst.CommandElements[-1] -split ',')) {
        $key, $value = $keyValue -split '='
        if ($key -eq 'type') {
            $type = $value
        }
    }

    if (!$type) {
        $type = 'volume' # Default type
        COMPGEN type string 'The type of mount'
    }

    if ($wordToComplete -notlike '*=*') {
        switch ($type) {
            bind {
                COMPGEN source string 'The source of mount'
                COMPGEN src string 'The abbreviation of "source"'
                COMPGEN destination string 'The destination of mount'
                COMPGEN dst string 'The abbreviation of "destination"'
                COMPGEN target string 'The alias of "destination"'
                COMPGEN readonly string 'true or 1 or no value: readonly, false or 0: read-write'
                COMPGEN ro string 'The abbreviation of "readonly"'
                COMPGEN consistency string 'The consistency requirements for the mount'
                COMPGEN bind-propagation string 'Refers to whether or not mounts created within a given bind mount or named volume can be propagated to replicas of that mount'
            }
            volume {
                COMPGEN source string 'The source of mount'
                COMPGEN src string 'The abbreviation of "source"'
                COMPGEN destination string 'The destination of mount'
                COMPGEN dst string 'The abbreviation of "destination"'
                COMPGEN target string 'The alias of "destination"'
                COMPGEN readonly string 'true or 1 or no value: readonly, false or 0: read-write'
                COMPGEN ro string 'The abbreviation of "readonly"'
                COMPGEN consistency string 'The consistency requirements for the mount'
                COMPGEN volume-driver string 'Name of the volume-driver plugin to use for the volume'
                COMPGEN volume-label string 'One or more custom metadata ("labels") to apply to the volume upon creation'
                COMPGEN volume-nocopy string 'To disable copying files from the container''s filesystem to the volume and mount the empty volume'
                COMPGEN volume-opt string 'Options specific to a given volume driver, which will be passed to the driver when creating the volume'
            }
            tmpfs {
                COMPGEN destination string 'The destination of mount'
                COMPGEN dst string 'The abbreviation of "destination"'
                COMPGEN target string 'The alias of "destination"'
                COMPGEN readonly string 'true or 1 or no value: readonly, false or 0: read-write'
                COMPGEN ro string 'The abbreviation of "readonly"'
                COMPGEN consistency string 'The consistency requirements for the mount'
                COMPGEN tmpfs-size string 'Size of the tmpfs mount in bytes'
                COMPGEN tmpfs-mode string 'File mode of the tmpfs in octal (e.g. "700" or "0700".)'
            }
        }
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        type { 'bind', 'volume', 'tmpfs' }
        { 'readonly', 'ro' -contains $_ } { 'true', 'false', 1, 0 }
        consistency {'default', 'consistent', 'cached', 'delegated'}
        bind-propagation { 'shared', 'slave', 'private', 'rshared', 'rslave', 'rprivate' }
        volume-nocopy { 'true', 'false' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}

Register-Completer docker_--log-level { 'debug', 'info', 'warn', 'error', 'fatal' }
Register-Completer docker_-l (Get-Completer docker_--log-level)
Register-Completer docker_--orchestrator { 'swarm', 'kubernetes' }

Register-Completer docker_config_inspect $configAll
Register-Completer docker_config_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN id string 'Config ID'
        COMPGEN name string 'Config name'
        COMPGEN label string 'Config label'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        id { docker config ls --quiet }
        name { docker config ls --format '{{.Name}}' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_config_rm $configAll

Register-Completer docker_container_attach $containerRunning
Register-Completer docker_container_commit {
    Param([string]$wordToComplete, $commandAst, $cursorPosition, $indexOfFirstArg)

    if ($indexOfFirstArg -lt 0) {
        Get-Container
    } else {
        $extent = $commandAst.CommandElements[$indexOfFirstArg].Extent
        if (($extent.StartOffset -le $cursorPosition) -and ($cursorPosition -le $extent.EndOffset)) {
            Get-Container
        } else {
            Get-Image
        }
    }
}
Register-Completer docker_container_create $imageAll
Register-Completer docker_container_create_--cap-add $capAddable
Register-Completer docker_container_create_--cap-drop $capDroppable
Register-Completer docker_container_create_--log-driver $logDriver
Register-Completer docker_container_create_--volume $volumeAll
Register-Completer docker_container_create_-v (Get-Completer docker_container_create_--volume)
Register-Completer docker_container_create_--volumes-from $containerAll
Register-Completer docker_container_diff $containerAll
Register-Completer docker_container_exec $containerRunning
Register-Completer docker_container_export $containerAll
Register-Completer docker_container_inspect $containerAll
Register-Completer docker_container_kill $containerRunning
Register-Completer docker_container_logs $containerAll
Register-Completer docker_container_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN ancestor string 'Filter containers which share a given image as an ancestor'
        COMPGEN before string 'Filter containers created before a given container ID or name'
        COMPGEN exited string 'Represent the container''s exit code. Only useful with --all'
        COMPGEN expose string 'Filter containers which expose a given port'
        COMPGEN health string 'Filter containers based on their healthcheck status'
        COMPGEN id string 'Container''s ID'
        COMPGEN isolation string 'Windows daemon only'
        COMPGEN is-task boolean 'Filter containers that are a "task" for a service'
        COMPGEN label string 'An arbitrary string representing either a key or a key-value pair'
        COMPGEN name string 'Container''s name'
        COMPGEN network string 'Filter running containers connected to a given network'
        COMPGEN publish string 'Filter containers which publish a given port'
        COMPGEN since string 'Filter containers created after a given container ID or name'
        COMPGEN status string 'Container''s status'
        COMPGEN volume string 'Filter running containers which have mounted a given volume or bind mount'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        ancestor { Get-Image }
        { 'before', 'since', 'name' -contains $_ } {
            Get-Container
        }
        health { 'starting', 'healthy', 'unhealthy', 'none' }
        id { docker container ls --format '{{.ID}}' --all }
        isolation { 'default', 'process', 'hyperv' }
        is-task { 'true', 'false' }
        network { Get-Network }
        status {
            'created'
            'dead'
            'exited'
            'paused'
            'removing'
            'restarting'
            'running'
        }
        volume { Get-Volume }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_container_ls_-f (Get-Completer docker_container_ls_--filter)
Register-Completer docker_container_ls_--format $formatBasic
Register-Completer docker_container_pause $containerRunning
Register-Completer docker_container_port $containerAll
Register-Completer docker_container_rename $containerAll
Register-Completer docker_container_restart $containerAll
Register-Completer docker_container_rm {
    Param($wordToComplete, $commandAst, $cursorPosition)

    $force = $false
    foreach ($ce in $commandAst.CommandElements) {
        if (@('--force', '-f') -contains $ce.Extent.Text) {
            $force = $true
            break
        }
    }

    if ($force) {
        Get-Container
    } else {
        Get-Container -Status created, exited
    }
}
Register-Completer docker_container_run $imageAll
Register-Completer docker_container_run_--cap-add $capAddable
Register-Completer docker_container_run_--cap-drop $capDroppable
Register-Completer docker_container_run_--log-driver $logDriver
Register-Completer docker_container_run_--network {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike 'container:*') {
        @(
            (docker system info --format '{{json .Plugins.Network}}' | ConvertFrom-Json)
            'container'
            Get-Network
        ) | Sort-Object -Unique
        return
    }

    $values = Get-Container

    foreach ($v in $values) {
        COMPGEN "container:$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_container_start { Get-Container -Status created, exited }
Register-Completer docker_container_run_--mount $mount
Register-Completer docker_container_run_--volume $volumeAll
Register-Completer docker_container_run_-v (Get-Completer docker_container_run_--volume)
Register-Completer docker_container_run_--volumes-from $containerAll
Register-Completer docker_container_stats $containerRunning
Register-Completer docker_container_stop $containerRunning
Register-Completer docker_container_top $containerRunning
Register-Completer docker_container_wait $containerAll

Register-Completer docker_image_build_--cache-from $imageAll
Register-Completer docker_image_build_--network {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike 'container:*') {
        @(
            (docker system info --format '{{json .Plugins.Network}}' | ConvertFrom-Json)
            'container'
            Get-Network
        ) | Sort-Object -Unique
        return
    }

    $values = Get-Container

    foreach ($v in $values) {
        COMPGEN "container:$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_image_build_--tag $imageAll
Register-Completer docker_image_build_-t (Get-Completer docker_image_build_--tag)
Register-Completer docker_image_history $imageAll
Register-Completer docker_image_import {
    Param([string]$wordToComplete, $commandAst, $cursorPosition, $indexOfFirstArg)

    if ($indexOfFirstArg -ge 0) {
        if ($commandAst.CommandElements[$indexOfFirstArg].Extent.EndOffset -lt $cursorPosition) {
            # 2nd arg
            Get-Image
        }
    }
}
Register-Completer docker_image_inspect $imageAll
Register-Completer docker_image_ls $imageAll
Register-Completer docker_image_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN before string 'Filter images created before a given container ID or name'
        COMPGEN dangling string 'Show untagged images'
        COMPGEN label string 'An arbitrary string representing either a key or a key-value pair'
        COMPGEN reference string 'Filter images whose reference matches the specified pattern'
        COMPGEN since string 'Filter images created after a given container ID or name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        { 'before', 'since', 'reference' -contains $_ } {
            Get-Image
        }
        dangling { 'true', 'false' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_image_ls_-f (Get-Completer docker_image_ls_--filter)
Register-Completer docker_image_ls_--format $formatBasic
Register-Completer docker_image_pull $imageAll
Register-Completer docker_image_pull_--all-tags { Get-ImageRepository }
Register-Completer docker_image_pull_-a { Get-ImageRepository }
Register-Completer docker_image_push $imageAll
Register-Completer docker_image_rm $imageAll
Register-Completer docker_image_save $imageAll
Register-Completer docker_image_tag $imageAll

Register-Completer docker_network_connect {
    Param([string]$wordToComplete, $commandAst, $cursorPosition, $indexOfFirstArg)

    if ($indexOfFirstArg -lt 0) {
        Get-Network
    } else {
        $extent = $commandAst.CommandElements[$indexOfFirstArg].Extent
        if (($extent.StartOffset -le $cursorPosition) -and ($cursorPosition -le $extent.EndOffset)) {
            Get-Network
        } else {
            Get-Container
        }
    }
}
Register-Completer docker_network_create_--driver {
    (docker system info --format '{{json .Plugins.Network}}' | ConvertFrom-Json) |
        Where-Object { $_ -notin @('host', 'null') }
}
Register-Completer docker_network_create_-d (Get-Completer docker_network_create_--driver)
Register-Completer docker_network_inspect $networkAll
Register-Completer docker_network_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN driver string 'Network driver'
        COMPGEN id string 'Network id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN name string 'Network name'
        COMPGEN scope string 'Scope name'
        COMPGEN type string 'Type name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        driver { docker system info --format '{{json .Plugins.Network}}' | ConvertFrom-Json }
        id { docker network ls --format '{{.ID}}' }
        name { docker network ls --format '{{.Name}}' }
        scope { 'global', 'local', 'swarm' }
        type { 'builtin', 'custom' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_network_ls_-f (Get-Completer docker_network_ls_--filter)
Register-Completer docker_network_rm { Get-Network -Type custom }

Register-Completer docker_node_demote { Get-Node -Role manager }
Register-Completer docker_node_inspect {
    Get-Node
    'self'
}
Register-Completer docker_node_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN id string 'Node id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN membership string 'accepted or pending'
        COMPGEN name string 'Node hostname'
        COMPGEN role string 'manager or worker'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        id { docker node ls --quiet }
        membership { 'accepted', 'pending' }
        name { docker node ls --format '{{.Hostname}}' }
        role { 'manager', 'worker' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_node_ls_-f (Get-Completer docker_node_ls_--filter)
Register-Completer docker_node_ls_--format {
    "'{{.Availability}}'"
    "'{{.Hostname}}'"
    "'{{.ID}}'"
    "'{{.ManagerStatus}}'"
    "'{{.Self}}'"
    "'{{.Status}}'"
    "'{{.TLSStatus}}'"
}
Register-Completer docker_node_promote { Get-Node -Role worker }
Register-Completer docker_node_ps {
    Get-Node
    'self'
}
Register-Completer docker_node_ps_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN desired-state string 'Desired state of the task'
        COMPGEN id string 'Task id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN name string 'Task name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        desired-state { 'accepted', 'running', 'shutdown' }
        id { docker node ps --quiet }
        name { docker node ps --format '{{.Name}}' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_node_ps_-f (Get-Completer docker_node_ps_--filter)
Register-Completer docker_node_ps_--format {
    "'{{.CurrentState}}'"
    "'{{.DesiredState}}'"
    "'{{.Error}}'"
    "'{{.Image}}'"
    "'{{.Name}}'"
    "'{{.Node}}'"
    "'{{.Ports}}'"
}
Register-Completer docker_node_rm { Get-Node }
Register-Completer docker_node_update { Get-Node }
Register-Completer docker_node_update_--availability { 'active', 'drain', 'pause' }
Register-Completer docker_node_update_--role { 'manager', 'worker' }

Register-Completer docker_plugin_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN capability string 'Plugin capabilities'
        COMPGEN enabled boolean 'True or false'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        capability { 'authz', 'ipamdriver', 'logdriver', 'metricscollector', 'networkdriver', 'volumedriver' }
        enabled { 'true', 'false' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_plugin_ls_-f (Get-Completer docker_plugin_ls_--filter)

Register-Completer docker_secret_inspect { Get-Secret }
Register-Completer docker_secret_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN id string 'Secret id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN name string 'Secret name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        id { docker secret ls --quiet }
        name { docker secret ls --format '{{.Name}}' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_secret_ls_-f (Get-Completer docker_secret_ls_--filter)
Register-Completer docker_secret_ls_--format {
    "'{{.CreatedAt}}'"
    "'{{.ID}}'"
    "'{{.Labels}}'"
    "'{{.Name}}'"
    "'{{.UpdatedAt}}'"
}
Register-Completer docker_secret_rm { Get-Secret }

Register-Completer docker_search_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN is-automated boolean 'Autobuild or not'
        COMPGEN is-official boolean 'Official repository or not'
        COMPGEN stars int 'Number of stars'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        is-automated { 'true', 'false' }
        is-official { 'true', 'false' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}

Register-Completer docker_service_create $imageAll
Register-Completer docker_service_create_--config $configAll
Register-Completer docker_service_create_--log-driver $logDriver
Register-Completer docker_service_create_--mode { 'global', 'replicated' }
Register-Completer docker_service_create_--mount $mount
Register-Completer docker_service_create_--restart-condition { 'any', 'none', 'on-failure' }
Register-Completer docker_service_create_--rollback-failure-action { 'continue', 'pause' }
Register-Completer docker_service_create_--rollback-order { 'start-first', 'stop-first' }
Register-Completer docker_service_create_--secret { Get-Secret }
Register-Completer docker_service_create_--update-failure-action { 'continue', 'pause', 'rollback' }
Register-Completer docker_service_create_--update-order { 'start-first', 'stop-first' }
Register-Completer docker_service_inspect $serviceAll
Register-Completer docker_service_logs {
    $services = Get-Service
    $services
    foreach ($s in $services) {
        docker service ps --format '{{.ID}}' $s
    }
}
Register-Completer docker_service_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN id string 'Service id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN mode string 'Service mode'
        COMPGEN name string 'Service name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        id { docker service ls --quiet }
        mode { 'global', 'replicated' }
        name { docker service ls --format '{{.Name}}' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_service_ps $serviceAll
Register-Completer docker_service_ps_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN desired-state string 'Desired state of the task'
        COMPGEN id string 'Task id'
        COMPGEN name string 'Task name'
        COMPGEN node string 'Node name or id'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        desired-state { 'accepted', 'running', 'shutdown' }
        id { docker node ps --quiet }
        name { docker node ps --format '{{.Name}}' }
        node {
            Get-Node
            'self'
        }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_service_ps_-f (Get-Completer docker_service_ps_--filter)
Register-Completer docker_service_rm $serviceAll
Register-Completer docker_service_scale {
    docker service ls --format '{{.Name}}' | ForEach-Object {
        COMPGEN "$_=" string $_ $_ ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_service_update $serviceAll
Register-Completer docker_service_update_--config-add $configAll
Register-Completer docker_service_update_--config-rm $configAll
Register-Completer docker_service_update_--image $imageAll
Register-Completer docker_service_update_--log-driver (Get-Completer docker_service_create_--log-driver)
Register-Completer docker_service_update_--mount-add $mount
Register-Completer docker_service_update_--network-add $networkAll
Register-Completer docker_service_update_--network-rm $networkAll
Register-Completer docker_service_update_--restart-condition (Get-Completer docker_service_create_--restart-condition)
Register-Completer docker_service_update_--rollback-failure-action (Get-Completer docker_service_create_--rollback-failure-action)
Register-Completer docker_service_update_--rollback-order (Get-Completer docker_service_create_--rollback-order)
Register-Completer docker_service_update_--secret-add { Get-Secret }
Register-Completer docker_service_update_--secret-rm { Get-Secret }
Register-Completer docker_service_update_--update-failure-action (Get-Completer docker_service_create_--update-failure-action)
Register-Completer docker_service_update_--update-order (Get-Completer docker_service_create_--update-order)

Register-Completer docker_stack_deploy $stackAll
Register-Completer docker_stack_ps $stackAll
Register-Completer docker_stack_ps_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN desired-state string 'Desired state of the task'
        COMPGEN id string 'Task id'
        COMPGEN name string 'Task name'
        COMPGEN node string 'Node name or id'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        desired-state { 'accepted', 'running', 'shutdown' }
        id { docker node ps --quiet }
        name { docker node ps --format '{{.Name}}' }
        node { Get-Node }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_stack_ps_-f (Get-Completer docker_stack_ps_--filter)
Register-Completer docker_stack_rm $stackAll
Register-Completer docker_stack_services $stackAll
Register-Completer docker_stack_services_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN id string 'Service id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN name string 'Service name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        id { docker service ls --quiet }
        name { docker service ls --format '{{.Name}}' }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_stack_services_-f (Get-Completer docker_stack_services_--filter)

Register-Completer docker_swarm_init_--availability { 'active', 'drain', 'pause' }
Register-Completer docker_swarm_join_--availability { 'active', 'drain', 'pause' }
Register-Completer docker_swarm_join-token { 'manager', 'worker' }

Register-Completer docker_system_df_--format $formatBasic
Register-Completer docker_system_events_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN container string 'Container name or id'
        COMPGEN daemon string 'Daemon name or id'
        COMPGEN event string 'Event name'
        COMPGEN image string 'Image name or id'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN network string 'Network name or id'
        COMPGEN plugin string 'Plugin name or id'
        COMPGEN scope string 'local or swarm'
        COMPGEN type string 'Object type'
        COMPGEN volume string 'Volume name or id'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        container { Get-Container }
        daemon {
            docker system info --format '{{.Name}}'
            docker system info --format '{{.ID}}'
        }
        event {
            'attach'
            'commit'
            'connect'
            'copy'
            'create'
            'delete'
            'destroy'
            'detach'
            'die'
            'disable'
            'disconnect'
            'enable'
            'exec_create'
            'exec_detach'
            'exec_start'
            'export'
            'health_status'
            'import'
            'install'
            'kill'
            'load'
            'mount'
            'oom'
            'pause'
            'pull'
            'push'
            'reload'
            'remove'
            'rename'
            'resize'
            'restart'
            'save'
            'start'
            'stop'
            'tag'
            'top'
            'unmount'
            'unpause'
            'untag'
            'update'
        }
        image { Get-Image }
        network { Get-Network }
        plugin { Get-Plugin }
        scope { 'local', 'swarm' }
        type { 'config', 'container', 'daemon', 'image', 'network', 'node', 'plugin', 'secret', 'service', 'volume' }
        volume { Get-Volume }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_system_events_-f (Get-Completer docker_system_events_--filter)
Register-Completer docker_system_events_--format $formatBasic
Register-Completer docker_system_info_--format $formatBasic

Register-Completer docker_trust_inspect $imageAll
Register-Completer docker_trust_revoke $imageAll
Register-Completer docker_trust_sign { Get-Image -WithTag }

Register-Completer docker_volume_inspect $volumeAll
Register-Completer docker_volume_ls_--filter {
    Param([string]$wordToComplete)

    if ($wordToComplete -notlike '*=*') {
        COMPGEN dangling string 'Referenced or not'
        COMPGEN driver string 'Volume''s driver name'
        COMPGEN label string '<key> or <key>=<value>'
        COMPGEN name string 'Volume''s name'
        return
    }

    $key = ($wordToComplete -split '=')[0]
    $values = switch ($key) {
        dangling { 'true', 'false' }
        driver { docker system info --format '{{json .Plugins.Volume}}' | ConvertFrom-Json }
        name { Get-Volume }
    }

    foreach ($v in $values) {
        COMPGEN "$key=$v" string $v $v ([System.Management.Automation.CompletionResultType]::ParameterValue)
    }
}
Register-Completer docker_volume_ls_-f (Get-Completer docker_volume_ls_--filter)
Register-Completer docker_volume_ls_--format {
    "'{{.Driver}}'"
    "'{{.Label}}'"
    "'{{.Labels}}'"
    "'{{.Mountpoint}}'"
    "'{{.Name}}'"
    "'{{.Scope}}'"
}

Register-Completer docker_volume_rm $volumeAll

Register-Completer docker_build_--cache-from (Get-Completer docker_image_build_--cache-from)
Register-Completer docker_build_--network (Get-Completer docker_image_build_--network)
Register-Completer docker_build_--tag (Get-Completer docker_image_build_--tag)
Register-Completer docker_build_-t (Get-Completer docker_build_--tag)

Register-Completer docker_run (Get-Completer docker_container_run)
Register-Completer docker_run_--cap-add (Get-Completer docker_container_run_--cap-add)
Register-Completer docker_run_--cap-drop (Get-Completer docker_container_run_--cap-drop)
Register-Completer docker_run_--mount (Get-Completer docker_container_run_--mount)
Register-Completer docker_run_--network (Get-Completer docker_container_run_--network)
Register-Completer docker_run_--log-driver (Get-Completer docker_container_run_--log-driver)
Register-Completer docker_run_--volume (Get-Completer docker_container_run_--volume)
Register-Completer docker_run_-v (Get-Completer docker_run_--volume)
Register-Completer docker_run_--volumes-from (Get-Completer docker_container_run_--volumes-from)

if ($env:DOCKER_HIDE_LEGACY_COMMANDS) {
    return
}

Register-Completer docker_attach (Get-Completer docker_container_attach)
Register-Completer docker_commit (Get-Completer docker_container_commit)
Register-Completer docker_create (Get-Completer docker_container_create)
Register-Completer docker_create_--cap-add (Get-Completer docker_container_create_--cap-add)
Register-Completer docker_create_--cap-drop (Get-Completer docker_container_create_--cap-drop)
Register-Completer docker_create_--log-driver (Get-Completer docker_container_create_--log-driver)
Register-Completer docker_create_--volume (Get-Completer docker_container_create_--volume)
Register-Completer docker_create_-v (Get-Completer docker_create_--volume)
Register-Completer docker_create_--volumes-from (Get-Completer docker_container_create_--volumes-from)
Register-Completer docker_diff (Get-Completer docker_container_diff)
Register-Completer docker_events_--filter (Get-Completer docker_system_events_--filter)
Register-Completer docker_events_-f (Get-Completer docker_events_--filter)
Register-Completer docker_events_--format (Get-Completer docker_system_events_--format)
Register-Completer docker_exec (Get-Completer docker_container_exec)
Register-Completer docker_export (Get-Completer docker_container_export)
Register-Completer docker_history (Get-Completer docker_image_history)
Register-Completer docker_images (Get-Completer docker_image_ls)
Register-Completer docker_import (Get-Completer docker_image_import)
Register-Completer docker_images_--filter (Get-Completer docker_image_ls_--filter)
Register-Completer docker_images_-f (Get-Completer docker_images_--filter)
Register-Completer docker_images_--format (Get-Completer docker_image_ls_--format)
Register-Completer docker_info_--format (Get-Completer docker_system_info_--format)
Register-Completer docker_inspect {
    Param($wordToComplete, $commandAst, $cursorPosition)

    $type = $null
    for ($i = 2; $i -lt $commandAst.CommandElements.Count; $i++) {
        $ce = $commandAst.CommandElements[$i]
        if ('--type' -eq $ce.Extent.Text) {
            $type = $commandAst.CommandElements[$i + 1].Extent.Text
            break
        }
    }

    switch ($type) {
        '' {
            Get-Container
            Get-Image
            Get-Network
            Get-Node
            Get-Plugin
            Get-Secret
            Get-Service
            Get-Volume
        }
        container { Get-Container }
        image { Get-Image }
        network { Get-Network }
        node { Get-Node }
        plugin { Get-Plugin }
        secret { Get-Secret }
        service { Get-Service }
        volume { Get-Volume }
    }
}
Register-Completer docker_inspect_--type { 'container', 'image', 'network', 'node', 'plugin', 'secret', 'service', 'volume' }
Register-Completer docker_kill (Get-Completer docker_container_kill)
Register-Completer docker_logs (Get-Completer docker_container_logs)
Register-Completer docker_pause (Get-Completer docker_container_pause)
Register-Completer docker_port (Get-Completer docker_container_port)
Register-Completer docker_ps_--filter (Get-Completer docker_container_ls_--filter)
Register-Completer docker_ps_-f (Get-Completer docker_ps_--filter)
Register-Completer docker_ps_--format (Get-Completer docker_container_ls_--format)
Register-Completer docker_pull (Get-Completer docker_image_pull)
Register-Completer docker_pull_--all-tags (Get-Completer docker_image_pull_--all-tags)
Register-Completer docker_pull_-a (Get-Completer docker_pull_--all-tags)
Register-Completer docker_push (Get-Completer docker_image_push)
Register-Completer docker_rename (Get-Completer docker_container_rename)
Register-Completer docker_restart (Get-Completer docker_container_restart)
Register-Completer docker_rm (Get-Completer docker_container_rm)
Register-Completer docker_rmi (Get-Completer docker_image_rm)
Register-Completer docker_save (Get-Completer docker_image_save)
Register-Completer docker_start (Get-Completer docker_container_start)
Register-Completer docker_stats (Get-Completer docker_container_stats)
Register-Completer docker_stop (Get-Completer docker_container_stop)
Register-Completer docker_tag (Get-Completer docker_image_tag)
Register-Completer docker_top (Get-Completer docker_container_top)
Register-Completer docker_wait (Get-Completer docker_container_wait)