Skip to main content

mq_rest_admin/
commands.rs

1//! MQSC command methods for `MqRestSession`.
2#![allow(clippy::missing_errors_doc)]
3
4use std::collections::HashMap;
5
6use serde_json::Value;
7
8use crate::error::Result;
9use crate::session::MqRestSession;
10
11impl MqRestSession {
12    // BEGIN GENERATED MQSC METHODS
13    /// Execute the MQSC `ALTER AUTHINFO` command.
14    pub fn alter_authinfo(
15        &mut self,
16        name: Option<&str>,
17        request_parameters: Option<&HashMap<String, Value>>,
18        response_parameters: Option<&[&str]>,
19    ) -> Result<()> {
20        self.mqsc_command(
21            "ALTER",
22            "AUTHINFO",
23            name,
24            request_parameters,
25            response_parameters,
26            None,
27        )?;
28        Ok(())
29    }
30
31    /// Execute the MQSC `ALTER BUFFPOOL` command.
32    pub fn alter_buffpool(
33        &mut self,
34        name: Option<&str>,
35        request_parameters: Option<&HashMap<String, Value>>,
36        response_parameters: Option<&[&str]>,
37    ) -> Result<()> {
38        self.mqsc_command(
39            "ALTER",
40            "BUFFPOOL",
41            name,
42            request_parameters,
43            response_parameters,
44            None,
45        )?;
46        Ok(())
47    }
48
49    /// Execute the MQSC `ALTER CFSTRUCT` command.
50    pub fn alter_cfstruct(
51        &mut self,
52        name: Option<&str>,
53        request_parameters: Option<&HashMap<String, Value>>,
54        response_parameters: Option<&[&str]>,
55    ) -> Result<()> {
56        self.mqsc_command(
57            "ALTER",
58            "CFSTRUCT",
59            name,
60            request_parameters,
61            response_parameters,
62            None,
63        )?;
64        Ok(())
65    }
66
67    /// Execute the MQSC `ALTER CHANNEL` command.
68    pub fn alter_channel(
69        &mut self,
70        name: Option<&str>,
71        request_parameters: Option<&HashMap<String, Value>>,
72        response_parameters: Option<&[&str]>,
73    ) -> Result<()> {
74        self.mqsc_command(
75            "ALTER",
76            "CHANNEL",
77            name,
78            request_parameters,
79            response_parameters,
80            None,
81        )?;
82        Ok(())
83    }
84
85    /// Execute the MQSC `ALTER COMMINFO` command.
86    pub fn alter_comminfo(
87        &mut self,
88        name: Option<&str>,
89        request_parameters: Option<&HashMap<String, Value>>,
90        response_parameters: Option<&[&str]>,
91    ) -> Result<()> {
92        self.mqsc_command(
93            "ALTER",
94            "COMMINFO",
95            name,
96            request_parameters,
97            response_parameters,
98            None,
99        )?;
100        Ok(())
101    }
102
103    /// Execute the MQSC `ALTER LISTENER` command.
104    pub fn alter_listener(
105        &mut self,
106        name: Option<&str>,
107        request_parameters: Option<&HashMap<String, Value>>,
108        response_parameters: Option<&[&str]>,
109    ) -> Result<()> {
110        self.mqsc_command(
111            "ALTER",
112            "LISTENER",
113            name,
114            request_parameters,
115            response_parameters,
116            None,
117        )?;
118        Ok(())
119    }
120
121    /// Execute the MQSC `ALTER NAMELIST` command.
122    pub fn alter_namelist(
123        &mut self,
124        name: Option<&str>,
125        request_parameters: Option<&HashMap<String, Value>>,
126        response_parameters: Option<&[&str]>,
127    ) -> Result<()> {
128        self.mqsc_command(
129            "ALTER",
130            "NAMELIST",
131            name,
132            request_parameters,
133            response_parameters,
134            None,
135        )?;
136        Ok(())
137    }
138
139    /// Execute the MQSC `ALTER PROCESS` command.
140    pub fn alter_process(
141        &mut self,
142        name: Option<&str>,
143        request_parameters: Option<&HashMap<String, Value>>,
144        response_parameters: Option<&[&str]>,
145    ) -> Result<()> {
146        self.mqsc_command(
147            "ALTER",
148            "PROCESS",
149            name,
150            request_parameters,
151            response_parameters,
152            None,
153        )?;
154        Ok(())
155    }
156
157    /// Execute the MQSC `ALTER PSID` command.
158    pub fn alter_psid(
159        &mut self,
160        name: Option<&str>,
161        request_parameters: Option<&HashMap<String, Value>>,
162        response_parameters: Option<&[&str]>,
163    ) -> Result<()> {
164        self.mqsc_command(
165            "ALTER",
166            "PSID",
167            name,
168            request_parameters,
169            response_parameters,
170            None,
171        )?;
172        Ok(())
173    }
174
175    /// Execute the MQSC `ALTER QALIAS` command.
176    pub fn alter_qalias(
177        &mut self,
178        name: Option<&str>,
179        request_parameters: Option<&HashMap<String, Value>>,
180        response_parameters: Option<&[&str]>,
181    ) -> Result<()> {
182        self.mqsc_command(
183            "ALTER",
184            "QALIAS",
185            name,
186            request_parameters,
187            response_parameters,
188            None,
189        )?;
190        Ok(())
191    }
192
193    /// Execute the MQSC `ALTER QLOCAL` command.
194    pub fn alter_qlocal(
195        &mut self,
196        name: Option<&str>,
197        request_parameters: Option<&HashMap<String, Value>>,
198        response_parameters: Option<&[&str]>,
199    ) -> Result<()> {
200        self.mqsc_command(
201            "ALTER",
202            "QLOCAL",
203            name,
204            request_parameters,
205            response_parameters,
206            None,
207        )?;
208        Ok(())
209    }
210
211    /// Execute the MQSC `ALTER QMGR` command.
212    pub fn alter_qmgr(
213        &mut self,
214        request_parameters: Option<&HashMap<String, Value>>,
215        response_parameters: Option<&[&str]>,
216    ) -> Result<()> {
217        self.mqsc_command(
218            "ALTER",
219            "QMGR",
220            None,
221            request_parameters,
222            response_parameters,
223            None,
224        )?;
225        Ok(())
226    }
227
228    /// Execute the MQSC `ALTER QMODEL` command.
229    pub fn alter_qmodel(
230        &mut self,
231        name: Option<&str>,
232        request_parameters: Option<&HashMap<String, Value>>,
233        response_parameters: Option<&[&str]>,
234    ) -> Result<()> {
235        self.mqsc_command(
236            "ALTER",
237            "QMODEL",
238            name,
239            request_parameters,
240            response_parameters,
241            None,
242        )?;
243        Ok(())
244    }
245
246    /// Execute the MQSC `ALTER QREMOTE` command.
247    pub fn alter_qremote(
248        &mut self,
249        name: Option<&str>,
250        request_parameters: Option<&HashMap<String, Value>>,
251        response_parameters: Option<&[&str]>,
252    ) -> Result<()> {
253        self.mqsc_command(
254            "ALTER",
255            "QREMOTE",
256            name,
257            request_parameters,
258            response_parameters,
259            None,
260        )?;
261        Ok(())
262    }
263
264    /// Execute the MQSC `ALTER SECURITY` command.
265    pub fn alter_security(
266        &mut self,
267        name: Option<&str>,
268        request_parameters: Option<&HashMap<String, Value>>,
269        response_parameters: Option<&[&str]>,
270    ) -> Result<()> {
271        self.mqsc_command(
272            "ALTER",
273            "SECURITY",
274            name,
275            request_parameters,
276            response_parameters,
277            None,
278        )?;
279        Ok(())
280    }
281
282    /// Execute the MQSC `ALTER SERVICE` command.
283    pub fn alter_service(
284        &mut self,
285        name: Option<&str>,
286        request_parameters: Option<&HashMap<String, Value>>,
287        response_parameters: Option<&[&str]>,
288    ) -> Result<()> {
289        self.mqsc_command(
290            "ALTER",
291            "SERVICE",
292            name,
293            request_parameters,
294            response_parameters,
295            None,
296        )?;
297        Ok(())
298    }
299
300    /// Execute the MQSC `ALTER SMDS` command.
301    pub fn alter_smds(
302        &mut self,
303        name: Option<&str>,
304        request_parameters: Option<&HashMap<String, Value>>,
305        response_parameters: Option<&[&str]>,
306    ) -> Result<()> {
307        self.mqsc_command(
308            "ALTER",
309            "SMDS",
310            name,
311            request_parameters,
312            response_parameters,
313            None,
314        )?;
315        Ok(())
316    }
317
318    /// Execute the MQSC `ALTER STGCLASS` command.
319    pub fn alter_stgclass(
320        &mut self,
321        name: Option<&str>,
322        request_parameters: Option<&HashMap<String, Value>>,
323        response_parameters: Option<&[&str]>,
324    ) -> Result<()> {
325        self.mqsc_command(
326            "ALTER",
327            "STGCLASS",
328            name,
329            request_parameters,
330            response_parameters,
331            None,
332        )?;
333        Ok(())
334    }
335
336    /// Execute the MQSC `ALTER SUB` command.
337    pub fn alter_sub(
338        &mut self,
339        name: Option<&str>,
340        request_parameters: Option<&HashMap<String, Value>>,
341        response_parameters: Option<&[&str]>,
342    ) -> Result<()> {
343        self.mqsc_command(
344            "ALTER",
345            "SUB",
346            name,
347            request_parameters,
348            response_parameters,
349            None,
350        )?;
351        Ok(())
352    }
353
354    /// Execute the MQSC `ALTER TOPIC` command.
355    pub fn alter_topic(
356        &mut self,
357        name: Option<&str>,
358        request_parameters: Option<&HashMap<String, Value>>,
359        response_parameters: Option<&[&str]>,
360    ) -> Result<()> {
361        self.mqsc_command(
362            "ALTER",
363            "TOPIC",
364            name,
365            request_parameters,
366            response_parameters,
367            None,
368        )?;
369        Ok(())
370    }
371
372    /// Execute the MQSC `ALTER TRACE` command.
373    pub fn alter_trace(
374        &mut self,
375        name: Option<&str>,
376        request_parameters: Option<&HashMap<String, Value>>,
377        response_parameters: Option<&[&str]>,
378    ) -> Result<()> {
379        self.mqsc_command(
380            "ALTER",
381            "TRACE",
382            name,
383            request_parameters,
384            response_parameters,
385            None,
386        )?;
387        Ok(())
388    }
389
390    /// Execute the MQSC `ARCHIVE LOG` command.
391    pub fn archive_log(
392        &mut self,
393        name: Option<&str>,
394        request_parameters: Option<&HashMap<String, Value>>,
395        response_parameters: Option<&[&str]>,
396    ) -> Result<()> {
397        self.mqsc_command(
398            "ARCHIVE",
399            "LOG",
400            name,
401            request_parameters,
402            response_parameters,
403            None,
404        )?;
405        Ok(())
406    }
407
408    /// Execute the MQSC `BACKUP CFSTRUCT` command.
409    pub fn backup_cfstruct(
410        &mut self,
411        name: Option<&str>,
412        request_parameters: Option<&HashMap<String, Value>>,
413        response_parameters: Option<&[&str]>,
414    ) -> Result<()> {
415        self.mqsc_command(
416            "BACKUP",
417            "CFSTRUCT",
418            name,
419            request_parameters,
420            response_parameters,
421            None,
422        )?;
423        Ok(())
424    }
425
426    /// Execute the MQSC `CLEAR QLOCAL` command.
427    pub fn clear_qlocal(
428        &mut self,
429        name: Option<&str>,
430        request_parameters: Option<&HashMap<String, Value>>,
431        response_parameters: Option<&[&str]>,
432    ) -> Result<()> {
433        self.mqsc_command(
434            "CLEAR",
435            "QLOCAL",
436            name,
437            request_parameters,
438            response_parameters,
439            None,
440        )?;
441        Ok(())
442    }
443
444    /// Execute the MQSC `CLEAR TOPICSTR` command.
445    pub fn clear_topicstr(
446        &mut self,
447        name: Option<&str>,
448        request_parameters: Option<&HashMap<String, Value>>,
449        response_parameters: Option<&[&str]>,
450    ) -> Result<()> {
451        self.mqsc_command(
452            "CLEAR",
453            "TOPICSTR",
454            name,
455            request_parameters,
456            response_parameters,
457            None,
458        )?;
459        Ok(())
460    }
461
462    /// Execute the MQSC `DEFINE AUTHINFO` command.
463    pub fn define_authinfo(
464        &mut self,
465        name: Option<&str>,
466        request_parameters: Option<&HashMap<String, Value>>,
467        response_parameters: Option<&[&str]>,
468    ) -> Result<()> {
469        self.mqsc_command(
470            "DEFINE",
471            "AUTHINFO",
472            name,
473            request_parameters,
474            response_parameters,
475            None,
476        )?;
477        Ok(())
478    }
479
480    /// Execute the MQSC `DEFINE BUFFPOOL` command.
481    pub fn define_buffpool(
482        &mut self,
483        name: Option<&str>,
484        request_parameters: Option<&HashMap<String, Value>>,
485        response_parameters: Option<&[&str]>,
486    ) -> Result<()> {
487        self.mqsc_command(
488            "DEFINE",
489            "BUFFPOOL",
490            name,
491            request_parameters,
492            response_parameters,
493            None,
494        )?;
495        Ok(())
496    }
497
498    /// Execute the MQSC `DEFINE CFSTRUCT` command.
499    pub fn define_cfstruct(
500        &mut self,
501        name: Option<&str>,
502        request_parameters: Option<&HashMap<String, Value>>,
503        response_parameters: Option<&[&str]>,
504    ) -> Result<()> {
505        self.mqsc_command(
506            "DEFINE",
507            "CFSTRUCT",
508            name,
509            request_parameters,
510            response_parameters,
511            None,
512        )?;
513        Ok(())
514    }
515
516    /// Execute the MQSC `DEFINE CHANNEL` command.
517    pub fn define_channel(
518        &mut self,
519        name: &str,
520        request_parameters: Option<&HashMap<String, Value>>,
521        response_parameters: Option<&[&str]>,
522    ) -> Result<()> {
523        self.mqsc_command(
524            "DEFINE",
525            "CHANNEL",
526            Some(name),
527            request_parameters,
528            response_parameters,
529            None,
530        )?;
531        Ok(())
532    }
533
534    /// Execute the MQSC `DEFINE COMMINFO` command.
535    pub fn define_comminfo(
536        &mut self,
537        name: Option<&str>,
538        request_parameters: Option<&HashMap<String, Value>>,
539        response_parameters: Option<&[&str]>,
540    ) -> Result<()> {
541        self.mqsc_command(
542            "DEFINE",
543            "COMMINFO",
544            name,
545            request_parameters,
546            response_parameters,
547            None,
548        )?;
549        Ok(())
550    }
551
552    /// Execute the MQSC `DEFINE LISTENER` command.
553    pub fn define_listener(
554        &mut self,
555        name: Option<&str>,
556        request_parameters: Option<&HashMap<String, Value>>,
557        response_parameters: Option<&[&str]>,
558    ) -> Result<()> {
559        self.mqsc_command(
560            "DEFINE",
561            "LISTENER",
562            name,
563            request_parameters,
564            response_parameters,
565            None,
566        )?;
567        Ok(())
568    }
569
570    /// Execute the MQSC `DEFINE LOG` command.
571    pub fn define_log(
572        &mut self,
573        name: Option<&str>,
574        request_parameters: Option<&HashMap<String, Value>>,
575        response_parameters: Option<&[&str]>,
576    ) -> Result<()> {
577        self.mqsc_command(
578            "DEFINE",
579            "LOG",
580            name,
581            request_parameters,
582            response_parameters,
583            None,
584        )?;
585        Ok(())
586    }
587
588    /// Execute the MQSC `DEFINE MAXSMSGS` command.
589    pub fn define_maxsmsgs(
590        &mut self,
591        name: Option<&str>,
592        request_parameters: Option<&HashMap<String, Value>>,
593        response_parameters: Option<&[&str]>,
594    ) -> Result<()> {
595        self.mqsc_command(
596            "DEFINE",
597            "MAXSMSGS",
598            name,
599            request_parameters,
600            response_parameters,
601            None,
602        )?;
603        Ok(())
604    }
605
606    /// Execute the MQSC `DEFINE NAMELIST` command.
607    pub fn define_namelist(
608        &mut self,
609        name: Option<&str>,
610        request_parameters: Option<&HashMap<String, Value>>,
611        response_parameters: Option<&[&str]>,
612    ) -> Result<()> {
613        self.mqsc_command(
614            "DEFINE",
615            "NAMELIST",
616            name,
617            request_parameters,
618            response_parameters,
619            None,
620        )?;
621        Ok(())
622    }
623
624    /// Execute the MQSC `DEFINE PROCESS` command.
625    pub fn define_process(
626        &mut self,
627        name: Option<&str>,
628        request_parameters: Option<&HashMap<String, Value>>,
629        response_parameters: Option<&[&str]>,
630    ) -> Result<()> {
631        self.mqsc_command(
632            "DEFINE",
633            "PROCESS",
634            name,
635            request_parameters,
636            response_parameters,
637            None,
638        )?;
639        Ok(())
640    }
641
642    /// Execute the MQSC `DEFINE PSID` command.
643    pub fn define_psid(
644        &mut self,
645        name: Option<&str>,
646        request_parameters: Option<&HashMap<String, Value>>,
647        response_parameters: Option<&[&str]>,
648    ) -> Result<()> {
649        self.mqsc_command(
650            "DEFINE",
651            "PSID",
652            name,
653            request_parameters,
654            response_parameters,
655            None,
656        )?;
657        Ok(())
658    }
659
660    /// Execute the MQSC `DEFINE QALIAS` command.
661    pub fn define_qalias(
662        &mut self,
663        name: &str,
664        request_parameters: Option<&HashMap<String, Value>>,
665        response_parameters: Option<&[&str]>,
666    ) -> Result<()> {
667        self.mqsc_command(
668            "DEFINE",
669            "QALIAS",
670            Some(name),
671            request_parameters,
672            response_parameters,
673            None,
674        )?;
675        Ok(())
676    }
677
678    /// Execute the MQSC `DEFINE QLOCAL` command.
679    pub fn define_qlocal(
680        &mut self,
681        name: &str,
682        request_parameters: Option<&HashMap<String, Value>>,
683        response_parameters: Option<&[&str]>,
684    ) -> Result<()> {
685        self.mqsc_command(
686            "DEFINE",
687            "QLOCAL",
688            Some(name),
689            request_parameters,
690            response_parameters,
691            None,
692        )?;
693        Ok(())
694    }
695
696    /// Execute the MQSC `DEFINE QMODEL` command.
697    pub fn define_qmodel(
698        &mut self,
699        name: &str,
700        request_parameters: Option<&HashMap<String, Value>>,
701        response_parameters: Option<&[&str]>,
702    ) -> Result<()> {
703        self.mqsc_command(
704            "DEFINE",
705            "QMODEL",
706            Some(name),
707            request_parameters,
708            response_parameters,
709            None,
710        )?;
711        Ok(())
712    }
713
714    /// Execute the MQSC `DEFINE QREMOTE` command.
715    pub fn define_qremote(
716        &mut self,
717        name: &str,
718        request_parameters: Option<&HashMap<String, Value>>,
719        response_parameters: Option<&[&str]>,
720    ) -> Result<()> {
721        self.mqsc_command(
722            "DEFINE",
723            "QREMOTE",
724            Some(name),
725            request_parameters,
726            response_parameters,
727            None,
728        )?;
729        Ok(())
730    }
731
732    /// Execute the MQSC `DEFINE SERVICE` command.
733    pub fn define_service(
734        &mut self,
735        name: Option<&str>,
736        request_parameters: Option<&HashMap<String, Value>>,
737        response_parameters: Option<&[&str]>,
738    ) -> Result<()> {
739        self.mqsc_command(
740            "DEFINE",
741            "SERVICE",
742            name,
743            request_parameters,
744            response_parameters,
745            None,
746        )?;
747        Ok(())
748    }
749
750    /// Execute the MQSC `DEFINE STGCLASS` command.
751    pub fn define_stgclass(
752        &mut self,
753        name: Option<&str>,
754        request_parameters: Option<&HashMap<String, Value>>,
755        response_parameters: Option<&[&str]>,
756    ) -> Result<()> {
757        self.mqsc_command(
758            "DEFINE",
759            "STGCLASS",
760            name,
761            request_parameters,
762            response_parameters,
763            None,
764        )?;
765        Ok(())
766    }
767
768    /// Execute the MQSC `DEFINE SUB` command.
769    pub fn define_sub(
770        &mut self,
771        name: Option<&str>,
772        request_parameters: Option<&HashMap<String, Value>>,
773        response_parameters: Option<&[&str]>,
774    ) -> Result<()> {
775        self.mqsc_command(
776            "DEFINE",
777            "SUB",
778            name,
779            request_parameters,
780            response_parameters,
781            None,
782        )?;
783        Ok(())
784    }
785
786    /// Execute the MQSC `DEFINE TOPIC` command.
787    pub fn define_topic(
788        &mut self,
789        name: Option<&str>,
790        request_parameters: Option<&HashMap<String, Value>>,
791        response_parameters: Option<&[&str]>,
792    ) -> Result<()> {
793        self.mqsc_command(
794            "DEFINE",
795            "TOPIC",
796            name,
797            request_parameters,
798            response_parameters,
799            None,
800        )?;
801        Ok(())
802    }
803
804    /// Execute the MQSC `DELETE AUTHINFO` command.
805    pub fn delete_authinfo(
806        &mut self,
807        name: Option<&str>,
808        request_parameters: Option<&HashMap<String, Value>>,
809        response_parameters: Option<&[&str]>,
810    ) -> Result<()> {
811        self.mqsc_command(
812            "DELETE",
813            "AUTHINFO",
814            name,
815            request_parameters,
816            response_parameters,
817            None,
818        )?;
819        Ok(())
820    }
821
822    /// Execute the MQSC `DELETE AUTHREC` command.
823    pub fn delete_authrec(
824        &mut self,
825        name: Option<&str>,
826        request_parameters: Option<&HashMap<String, Value>>,
827        response_parameters: Option<&[&str]>,
828    ) -> Result<()> {
829        self.mqsc_command(
830            "DELETE",
831            "AUTHREC",
832            name,
833            request_parameters,
834            response_parameters,
835            None,
836        )?;
837        Ok(())
838    }
839
840    /// Execute the MQSC `DELETE BUFFPOOL` command.
841    pub fn delete_buffpool(
842        &mut self,
843        name: Option<&str>,
844        request_parameters: Option<&HashMap<String, Value>>,
845        response_parameters: Option<&[&str]>,
846    ) -> Result<()> {
847        self.mqsc_command(
848            "DELETE",
849            "BUFFPOOL",
850            name,
851            request_parameters,
852            response_parameters,
853            None,
854        )?;
855        Ok(())
856    }
857
858    /// Execute the MQSC `DELETE CFSTRUCT` command.
859    pub fn delete_cfstruct(
860        &mut self,
861        name: Option<&str>,
862        request_parameters: Option<&HashMap<String, Value>>,
863        response_parameters: Option<&[&str]>,
864    ) -> Result<()> {
865        self.mqsc_command(
866            "DELETE",
867            "CFSTRUCT",
868            name,
869            request_parameters,
870            response_parameters,
871            None,
872        )?;
873        Ok(())
874    }
875
876    /// Execute the MQSC `DELETE CHANNEL` command.
877    pub fn delete_channel(
878        &mut self,
879        name: &str,
880        request_parameters: Option<&HashMap<String, Value>>,
881        response_parameters: Option<&[&str]>,
882    ) -> Result<()> {
883        self.mqsc_command(
884            "DELETE",
885            "CHANNEL",
886            Some(name),
887            request_parameters,
888            response_parameters,
889            None,
890        )?;
891        Ok(())
892    }
893
894    /// Execute the MQSC `DELETE COMMINFO` command.
895    pub fn delete_comminfo(
896        &mut self,
897        name: Option<&str>,
898        request_parameters: Option<&HashMap<String, Value>>,
899        response_parameters: Option<&[&str]>,
900    ) -> Result<()> {
901        self.mqsc_command(
902            "DELETE",
903            "COMMINFO",
904            name,
905            request_parameters,
906            response_parameters,
907            None,
908        )?;
909        Ok(())
910    }
911
912    /// Execute the MQSC `DELETE LISTENER` command.
913    pub fn delete_listener(
914        &mut self,
915        name: Option<&str>,
916        request_parameters: Option<&HashMap<String, Value>>,
917        response_parameters: Option<&[&str]>,
918    ) -> Result<()> {
919        self.mqsc_command(
920            "DELETE",
921            "LISTENER",
922            name,
923            request_parameters,
924            response_parameters,
925            None,
926        )?;
927        Ok(())
928    }
929
930    /// Execute the MQSC `DELETE NAMELIST` command.
931    pub fn delete_namelist(
932        &mut self,
933        name: Option<&str>,
934        request_parameters: Option<&HashMap<String, Value>>,
935        response_parameters: Option<&[&str]>,
936    ) -> Result<()> {
937        self.mqsc_command(
938            "DELETE",
939            "NAMELIST",
940            name,
941            request_parameters,
942            response_parameters,
943            None,
944        )?;
945        Ok(())
946    }
947
948    /// Execute the MQSC `DELETE POLICY` command.
949    pub fn delete_policy(
950        &mut self,
951        name: Option<&str>,
952        request_parameters: Option<&HashMap<String, Value>>,
953        response_parameters: Option<&[&str]>,
954    ) -> Result<()> {
955        self.mqsc_command(
956            "DELETE",
957            "POLICY",
958            name,
959            request_parameters,
960            response_parameters,
961            None,
962        )?;
963        Ok(())
964    }
965
966    /// Execute the MQSC `DELETE PROCESS` command.
967    pub fn delete_process(
968        &mut self,
969        name: Option<&str>,
970        request_parameters: Option<&HashMap<String, Value>>,
971        response_parameters: Option<&[&str]>,
972    ) -> Result<()> {
973        self.mqsc_command(
974            "DELETE",
975            "PROCESS",
976            name,
977            request_parameters,
978            response_parameters,
979            None,
980        )?;
981        Ok(())
982    }
983
984    /// Execute the MQSC `DELETE PSID` command.
985    pub fn delete_psid(
986        &mut self,
987        name: Option<&str>,
988        request_parameters: Option<&HashMap<String, Value>>,
989        response_parameters: Option<&[&str]>,
990    ) -> Result<()> {
991        self.mqsc_command(
992            "DELETE",
993            "PSID",
994            name,
995            request_parameters,
996            response_parameters,
997            None,
998        )?;
999        Ok(())
1000    }
1001
1002    /// Execute the MQSC `DELETE QALIAS` command.
1003    pub fn delete_qalias(
1004        &mut self,
1005        name: &str,
1006        request_parameters: Option<&HashMap<String, Value>>,
1007        response_parameters: Option<&[&str]>,
1008    ) -> Result<()> {
1009        self.mqsc_command(
1010            "DELETE",
1011            "QALIAS",
1012            Some(name),
1013            request_parameters,
1014            response_parameters,
1015            None,
1016        )?;
1017        Ok(())
1018    }
1019
1020    /// Execute the MQSC `DELETE QLOCAL` command.
1021    pub fn delete_qlocal(
1022        &mut self,
1023        name: &str,
1024        request_parameters: Option<&HashMap<String, Value>>,
1025        response_parameters: Option<&[&str]>,
1026    ) -> Result<()> {
1027        self.mqsc_command(
1028            "DELETE",
1029            "QLOCAL",
1030            Some(name),
1031            request_parameters,
1032            response_parameters,
1033            None,
1034        )?;
1035        Ok(())
1036    }
1037
1038    /// Execute the MQSC `DELETE QMODEL` command.
1039    pub fn delete_qmodel(
1040        &mut self,
1041        name: &str,
1042        request_parameters: Option<&HashMap<String, Value>>,
1043        response_parameters: Option<&[&str]>,
1044    ) -> Result<()> {
1045        self.mqsc_command(
1046            "DELETE",
1047            "QMODEL",
1048            Some(name),
1049            request_parameters,
1050            response_parameters,
1051            None,
1052        )?;
1053        Ok(())
1054    }
1055
1056    /// Execute the MQSC `DELETE QREMOTE` command.
1057    pub fn delete_qremote(
1058        &mut self,
1059        name: &str,
1060        request_parameters: Option<&HashMap<String, Value>>,
1061        response_parameters: Option<&[&str]>,
1062    ) -> Result<()> {
1063        self.mqsc_command(
1064            "DELETE",
1065            "QREMOTE",
1066            Some(name),
1067            request_parameters,
1068            response_parameters,
1069            None,
1070        )?;
1071        Ok(())
1072    }
1073
1074    /// Execute the MQSC `DELETE QUEUE` command.
1075    pub fn delete_queue(
1076        &mut self,
1077        name: &str,
1078        request_parameters: Option<&HashMap<String, Value>>,
1079        response_parameters: Option<&[&str]>,
1080    ) -> Result<()> {
1081        self.mqsc_command(
1082            "DELETE",
1083            "QUEUE",
1084            Some(name),
1085            request_parameters,
1086            response_parameters,
1087            None,
1088        )?;
1089        Ok(())
1090    }
1091
1092    /// Execute the MQSC `DELETE SERVICE` command.
1093    pub fn delete_service(
1094        &mut self,
1095        name: Option<&str>,
1096        request_parameters: Option<&HashMap<String, Value>>,
1097        response_parameters: Option<&[&str]>,
1098    ) -> Result<()> {
1099        self.mqsc_command(
1100            "DELETE",
1101            "SERVICE",
1102            name,
1103            request_parameters,
1104            response_parameters,
1105            None,
1106        )?;
1107        Ok(())
1108    }
1109
1110    /// Execute the MQSC `DELETE STGCLASS` command.
1111    pub fn delete_stgclass(
1112        &mut self,
1113        name: Option<&str>,
1114        request_parameters: Option<&HashMap<String, Value>>,
1115        response_parameters: Option<&[&str]>,
1116    ) -> Result<()> {
1117        self.mqsc_command(
1118            "DELETE",
1119            "STGCLASS",
1120            name,
1121            request_parameters,
1122            response_parameters,
1123            None,
1124        )?;
1125        Ok(())
1126    }
1127
1128    /// Execute the MQSC `DELETE SUB` command.
1129    pub fn delete_sub(
1130        &mut self,
1131        name: Option<&str>,
1132        request_parameters: Option<&HashMap<String, Value>>,
1133        response_parameters: Option<&[&str]>,
1134    ) -> Result<()> {
1135        self.mqsc_command(
1136            "DELETE",
1137            "SUB",
1138            name,
1139            request_parameters,
1140            response_parameters,
1141            None,
1142        )?;
1143        Ok(())
1144    }
1145
1146    /// Execute the MQSC `DELETE TOPIC` command.
1147    pub fn delete_topic(
1148        &mut self,
1149        name: Option<&str>,
1150        request_parameters: Option<&HashMap<String, Value>>,
1151        response_parameters: Option<&[&str]>,
1152    ) -> Result<()> {
1153        self.mqsc_command(
1154            "DELETE",
1155            "TOPIC",
1156            name,
1157            request_parameters,
1158            response_parameters,
1159            None,
1160        )?;
1161        Ok(())
1162    }
1163
1164    /// Execute the MQSC `DISPLAY APSTATUS` command.
1165    pub fn display_apstatus(
1166        &mut self,
1167        name: Option<&str>,
1168        request_parameters: Option<&HashMap<String, Value>>,
1169        response_parameters: Option<&[&str]>,
1170        where_clause: Option<&str>,
1171    ) -> Result<Vec<HashMap<String, Value>>> {
1172        self.mqsc_command(
1173            "DISPLAY",
1174            "APSTATUS",
1175            name,
1176            request_parameters,
1177            response_parameters,
1178            where_clause,
1179        )
1180    }
1181
1182    /// Execute the MQSC `DISPLAY ARCHIVE` command.
1183    pub fn display_archive(
1184        &mut self,
1185        name: Option<&str>,
1186        request_parameters: Option<&HashMap<String, Value>>,
1187        response_parameters: Option<&[&str]>,
1188        where_clause: Option<&str>,
1189    ) -> Result<Vec<HashMap<String, Value>>> {
1190        self.mqsc_command(
1191            "DISPLAY",
1192            "ARCHIVE",
1193            name,
1194            request_parameters,
1195            response_parameters,
1196            where_clause,
1197        )
1198    }
1199
1200    /// Execute the MQSC `DISPLAY AUTHINFO` command.
1201    pub fn display_authinfo(
1202        &mut self,
1203        name: Option<&str>,
1204        request_parameters: Option<&HashMap<String, Value>>,
1205        response_parameters: Option<&[&str]>,
1206        where_clause: Option<&str>,
1207    ) -> Result<Vec<HashMap<String, Value>>> {
1208        self.mqsc_command(
1209            "DISPLAY",
1210            "AUTHINFO",
1211            name,
1212            request_parameters,
1213            response_parameters,
1214            where_clause,
1215        )
1216    }
1217
1218    /// Execute the MQSC `DISPLAY AUTHREC` command.
1219    pub fn display_authrec(
1220        &mut self,
1221        name: Option<&str>,
1222        request_parameters: Option<&HashMap<String, Value>>,
1223        response_parameters: Option<&[&str]>,
1224        where_clause: Option<&str>,
1225    ) -> Result<Vec<HashMap<String, Value>>> {
1226        self.mqsc_command(
1227            "DISPLAY",
1228            "AUTHREC",
1229            name,
1230            request_parameters,
1231            response_parameters,
1232            where_clause,
1233        )
1234    }
1235
1236    /// Execute the MQSC `DISPLAY AUTHSERV` command.
1237    pub fn display_authserv(
1238        &mut self,
1239        name: Option<&str>,
1240        request_parameters: Option<&HashMap<String, Value>>,
1241        response_parameters: Option<&[&str]>,
1242        where_clause: Option<&str>,
1243    ) -> Result<Vec<HashMap<String, Value>>> {
1244        self.mqsc_command(
1245            "DISPLAY",
1246            "AUTHSERV",
1247            name,
1248            request_parameters,
1249            response_parameters,
1250            where_clause,
1251        )
1252    }
1253
1254    /// Execute the MQSC `DISPLAY CFSTATUS` command.
1255    pub fn display_cfstatus(
1256        &mut self,
1257        name: Option<&str>,
1258        request_parameters: Option<&HashMap<String, Value>>,
1259        response_parameters: Option<&[&str]>,
1260        where_clause: Option<&str>,
1261    ) -> Result<Vec<HashMap<String, Value>>> {
1262        self.mqsc_command(
1263            "DISPLAY",
1264            "CFSTATUS",
1265            name,
1266            request_parameters,
1267            response_parameters,
1268            where_clause,
1269        )
1270    }
1271
1272    /// Execute the MQSC `DISPLAY CFSTRUCT` command.
1273    pub fn display_cfstruct(
1274        &mut self,
1275        name: Option<&str>,
1276        request_parameters: Option<&HashMap<String, Value>>,
1277        response_parameters: Option<&[&str]>,
1278        where_clause: Option<&str>,
1279    ) -> Result<Vec<HashMap<String, Value>>> {
1280        self.mqsc_command(
1281            "DISPLAY",
1282            "CFSTRUCT",
1283            name,
1284            request_parameters,
1285            response_parameters,
1286            where_clause,
1287        )
1288    }
1289
1290    /// Execute the MQSC `DISPLAY CHANNEL` command.
1291    pub fn display_channel(
1292        &mut self,
1293        name: Option<&str>,
1294        request_parameters: Option<&HashMap<String, Value>>,
1295        response_parameters: Option<&[&str]>,
1296        where_clause: Option<&str>,
1297    ) -> Result<Vec<HashMap<String, Value>>> {
1298        self.mqsc_command(
1299            "DISPLAY",
1300            "CHANNEL",
1301            Some(name.unwrap_or("*")),
1302            request_parameters,
1303            response_parameters,
1304            where_clause,
1305        )
1306    }
1307
1308    /// Execute the MQSC `DISPLAY CHINIT` command.
1309    pub fn display_chinit(
1310        &mut self,
1311        name: Option<&str>,
1312        request_parameters: Option<&HashMap<String, Value>>,
1313        response_parameters: Option<&[&str]>,
1314        where_clause: Option<&str>,
1315    ) -> Result<Vec<HashMap<String, Value>>> {
1316        self.mqsc_command(
1317            "DISPLAY",
1318            "CHINIT",
1319            name,
1320            request_parameters,
1321            response_parameters,
1322            where_clause,
1323        )
1324    }
1325
1326    /// Execute the MQSC `DISPLAY CHLAUTH` command.
1327    pub fn display_chlauth(
1328        &mut self,
1329        name: Option<&str>,
1330        request_parameters: Option<&HashMap<String, Value>>,
1331        response_parameters: Option<&[&str]>,
1332        where_clause: Option<&str>,
1333    ) -> Result<Vec<HashMap<String, Value>>> {
1334        self.mqsc_command(
1335            "DISPLAY",
1336            "CHLAUTH",
1337            name,
1338            request_parameters,
1339            response_parameters,
1340            where_clause,
1341        )
1342    }
1343
1344    /// Execute the MQSC `DISPLAY CHSTATUS` command.
1345    pub fn display_chstatus(
1346        &mut self,
1347        name: Option<&str>,
1348        request_parameters: Option<&HashMap<String, Value>>,
1349        response_parameters: Option<&[&str]>,
1350        where_clause: Option<&str>,
1351    ) -> Result<Vec<HashMap<String, Value>>> {
1352        self.mqsc_command(
1353            "DISPLAY",
1354            "CHSTATUS",
1355            name,
1356            request_parameters,
1357            response_parameters,
1358            where_clause,
1359        )
1360    }
1361
1362    /// Execute the MQSC `DISPLAY CLUSQMGR` command.
1363    pub fn display_clusqmgr(
1364        &mut self,
1365        name: Option<&str>,
1366        request_parameters: Option<&HashMap<String, Value>>,
1367        response_parameters: Option<&[&str]>,
1368        where_clause: Option<&str>,
1369    ) -> Result<Vec<HashMap<String, Value>>> {
1370        self.mqsc_command(
1371            "DISPLAY",
1372            "CLUSQMGR",
1373            name,
1374            request_parameters,
1375            response_parameters,
1376            where_clause,
1377        )
1378    }
1379
1380    /// Execute the MQSC `DISPLAY CMDSERV` command.
1381    pub fn display_cmdserv(
1382        &mut self,
1383        request_parameters: Option<&HashMap<String, Value>>,
1384        response_parameters: Option<&[&str]>,
1385    ) -> Result<Option<HashMap<String, Value>>> {
1386        let objects = self.mqsc_command(
1387            "DISPLAY",
1388            "CMDSERV",
1389            None,
1390            request_parameters,
1391            response_parameters,
1392            None,
1393        )?;
1394        Ok(objects.into_iter().next())
1395    }
1396
1397    /// Execute the MQSC `DISPLAY COMMINFO` command.
1398    pub fn display_comminfo(
1399        &mut self,
1400        name: Option<&str>,
1401        request_parameters: Option<&HashMap<String, Value>>,
1402        response_parameters: Option<&[&str]>,
1403        where_clause: Option<&str>,
1404    ) -> Result<Vec<HashMap<String, Value>>> {
1405        self.mqsc_command(
1406            "DISPLAY",
1407            "COMMINFO",
1408            name,
1409            request_parameters,
1410            response_parameters,
1411            where_clause,
1412        )
1413    }
1414
1415    /// Execute the MQSC `DISPLAY CONN` command.
1416    pub fn display_conn(
1417        &mut self,
1418        name: Option<&str>,
1419        request_parameters: Option<&HashMap<String, Value>>,
1420        response_parameters: Option<&[&str]>,
1421        where_clause: Option<&str>,
1422    ) -> Result<Vec<HashMap<String, Value>>> {
1423        self.mqsc_command(
1424            "DISPLAY",
1425            "CONN",
1426            name,
1427            request_parameters,
1428            response_parameters,
1429            where_clause,
1430        )
1431    }
1432
1433    /// Execute the MQSC `DISPLAY ENTAUTH` command.
1434    pub fn display_entauth(
1435        &mut self,
1436        name: Option<&str>,
1437        request_parameters: Option<&HashMap<String, Value>>,
1438        response_parameters: Option<&[&str]>,
1439        where_clause: Option<&str>,
1440    ) -> Result<Vec<HashMap<String, Value>>> {
1441        self.mqsc_command(
1442            "DISPLAY",
1443            "ENTAUTH",
1444            name,
1445            request_parameters,
1446            response_parameters,
1447            where_clause,
1448        )
1449    }
1450
1451    /// Execute the MQSC `DISPLAY GROUP` command.
1452    pub fn display_group(
1453        &mut self,
1454        name: Option<&str>,
1455        request_parameters: Option<&HashMap<String, Value>>,
1456        response_parameters: Option<&[&str]>,
1457        where_clause: Option<&str>,
1458    ) -> Result<Vec<HashMap<String, Value>>> {
1459        self.mqsc_command(
1460            "DISPLAY",
1461            "GROUP",
1462            name,
1463            request_parameters,
1464            response_parameters,
1465            where_clause,
1466        )
1467    }
1468
1469    /// Execute the MQSC `DISPLAY LISTENER` command.
1470    pub fn display_listener(
1471        &mut self,
1472        name: Option<&str>,
1473        request_parameters: Option<&HashMap<String, Value>>,
1474        response_parameters: Option<&[&str]>,
1475        where_clause: Option<&str>,
1476    ) -> Result<Vec<HashMap<String, Value>>> {
1477        self.mqsc_command(
1478            "DISPLAY",
1479            "LISTENER",
1480            name,
1481            request_parameters,
1482            response_parameters,
1483            where_clause,
1484        )
1485    }
1486
1487    /// Execute the MQSC `DISPLAY LOG` command.
1488    pub fn display_log(
1489        &mut self,
1490        name: Option<&str>,
1491        request_parameters: Option<&HashMap<String, Value>>,
1492        response_parameters: Option<&[&str]>,
1493        where_clause: Option<&str>,
1494    ) -> Result<Vec<HashMap<String, Value>>> {
1495        self.mqsc_command(
1496            "DISPLAY",
1497            "LOG",
1498            name,
1499            request_parameters,
1500            response_parameters,
1501            where_clause,
1502        )
1503    }
1504
1505    /// Execute the MQSC `DISPLAY LSSTATUS` command.
1506    pub fn display_lsstatus(
1507        &mut self,
1508        name: Option<&str>,
1509        request_parameters: Option<&HashMap<String, Value>>,
1510        response_parameters: Option<&[&str]>,
1511        where_clause: Option<&str>,
1512    ) -> Result<Vec<HashMap<String, Value>>> {
1513        self.mqsc_command(
1514            "DISPLAY",
1515            "LSSTATUS",
1516            name,
1517            request_parameters,
1518            response_parameters,
1519            where_clause,
1520        )
1521    }
1522
1523    /// Execute the MQSC `DISPLAY MAXSMSGS` command.
1524    pub fn display_maxsmsgs(
1525        &mut self,
1526        name: Option<&str>,
1527        request_parameters: Option<&HashMap<String, Value>>,
1528        response_parameters: Option<&[&str]>,
1529        where_clause: Option<&str>,
1530    ) -> Result<Vec<HashMap<String, Value>>> {
1531        self.mqsc_command(
1532            "DISPLAY",
1533            "MAXSMSGS",
1534            name,
1535            request_parameters,
1536            response_parameters,
1537            where_clause,
1538        )
1539    }
1540
1541    /// Execute the MQSC `DISPLAY NAMELIST` command.
1542    pub fn display_namelist(
1543        &mut self,
1544        name: Option<&str>,
1545        request_parameters: Option<&HashMap<String, Value>>,
1546        response_parameters: Option<&[&str]>,
1547        where_clause: Option<&str>,
1548    ) -> Result<Vec<HashMap<String, Value>>> {
1549        self.mqsc_command(
1550            "DISPLAY",
1551            "NAMELIST",
1552            name,
1553            request_parameters,
1554            response_parameters,
1555            where_clause,
1556        )
1557    }
1558
1559    /// Execute the MQSC `DISPLAY POLICY` command.
1560    pub fn display_policy(
1561        &mut self,
1562        name: Option<&str>,
1563        request_parameters: Option<&HashMap<String, Value>>,
1564        response_parameters: Option<&[&str]>,
1565        where_clause: Option<&str>,
1566    ) -> Result<Vec<HashMap<String, Value>>> {
1567        self.mqsc_command(
1568            "DISPLAY",
1569            "POLICY",
1570            name,
1571            request_parameters,
1572            response_parameters,
1573            where_clause,
1574        )
1575    }
1576
1577    /// Execute the MQSC `DISPLAY PROCESS` command.
1578    pub fn display_process(
1579        &mut self,
1580        name: Option<&str>,
1581        request_parameters: Option<&HashMap<String, Value>>,
1582        response_parameters: Option<&[&str]>,
1583        where_clause: Option<&str>,
1584    ) -> Result<Vec<HashMap<String, Value>>> {
1585        self.mqsc_command(
1586            "DISPLAY",
1587            "PROCESS",
1588            name,
1589            request_parameters,
1590            response_parameters,
1591            where_clause,
1592        )
1593    }
1594
1595    /// Execute the MQSC `DISPLAY PUBSUB` command.
1596    pub fn display_pubsub(
1597        &mut self,
1598        name: Option<&str>,
1599        request_parameters: Option<&HashMap<String, Value>>,
1600        response_parameters: Option<&[&str]>,
1601        where_clause: Option<&str>,
1602    ) -> Result<Vec<HashMap<String, Value>>> {
1603        self.mqsc_command(
1604            "DISPLAY",
1605            "PUBSUB",
1606            name,
1607            request_parameters,
1608            response_parameters,
1609            where_clause,
1610        )
1611    }
1612
1613    /// Execute the MQSC `DISPLAY QMGR` command.
1614    pub fn display_qmgr(
1615        &mut self,
1616        request_parameters: Option<&HashMap<String, Value>>,
1617        response_parameters: Option<&[&str]>,
1618    ) -> Result<Option<HashMap<String, Value>>> {
1619        let objects = self.mqsc_command(
1620            "DISPLAY",
1621            "QMGR",
1622            None,
1623            request_parameters,
1624            response_parameters,
1625            None,
1626        )?;
1627        Ok(objects.into_iter().next())
1628    }
1629
1630    /// Execute the MQSC `DISPLAY QMSTATUS` command.
1631    pub fn display_qmstatus(
1632        &mut self,
1633        request_parameters: Option<&HashMap<String, Value>>,
1634        response_parameters: Option<&[&str]>,
1635    ) -> Result<Option<HashMap<String, Value>>> {
1636        let objects = self.mqsc_command(
1637            "DISPLAY",
1638            "QMSTATUS",
1639            None,
1640            request_parameters,
1641            response_parameters,
1642            None,
1643        )?;
1644        Ok(objects.into_iter().next())
1645    }
1646
1647    /// Execute the MQSC `DISPLAY QSTATUS` command.
1648    pub fn display_qstatus(
1649        &mut self,
1650        name: Option<&str>,
1651        request_parameters: Option<&HashMap<String, Value>>,
1652        response_parameters: Option<&[&str]>,
1653        where_clause: Option<&str>,
1654    ) -> Result<Vec<HashMap<String, Value>>> {
1655        self.mqsc_command(
1656            "DISPLAY",
1657            "QSTATUS",
1658            name,
1659            request_parameters,
1660            response_parameters,
1661            where_clause,
1662        )
1663    }
1664
1665    /// Execute the MQSC `DISPLAY QUEUE` command.
1666    pub fn display_queue(
1667        &mut self,
1668        name: Option<&str>,
1669        request_parameters: Option<&HashMap<String, Value>>,
1670        response_parameters: Option<&[&str]>,
1671        where_clause: Option<&str>,
1672    ) -> Result<Vec<HashMap<String, Value>>> {
1673        self.mqsc_command(
1674            "DISPLAY",
1675            "QUEUE",
1676            Some(name.unwrap_or("*")),
1677            request_parameters,
1678            response_parameters,
1679            where_clause,
1680        )
1681    }
1682
1683    /// Execute the MQSC `DISPLAY SBSTATUS` command.
1684    pub fn display_sbstatus(
1685        &mut self,
1686        name: Option<&str>,
1687        request_parameters: Option<&HashMap<String, Value>>,
1688        response_parameters: Option<&[&str]>,
1689        where_clause: Option<&str>,
1690    ) -> Result<Vec<HashMap<String, Value>>> {
1691        self.mqsc_command(
1692            "DISPLAY",
1693            "SBSTATUS",
1694            name,
1695            request_parameters,
1696            response_parameters,
1697            where_clause,
1698        )
1699    }
1700
1701    /// Execute the MQSC `DISPLAY SECURITY` command.
1702    pub fn display_security(
1703        &mut self,
1704        name: Option<&str>,
1705        request_parameters: Option<&HashMap<String, Value>>,
1706        response_parameters: Option<&[&str]>,
1707        where_clause: Option<&str>,
1708    ) -> Result<Vec<HashMap<String, Value>>> {
1709        self.mqsc_command(
1710            "DISPLAY",
1711            "SECURITY",
1712            name,
1713            request_parameters,
1714            response_parameters,
1715            where_clause,
1716        )
1717    }
1718
1719    /// Execute the MQSC `DISPLAY SERVICE` command.
1720    pub fn display_service(
1721        &mut self,
1722        name: Option<&str>,
1723        request_parameters: Option<&HashMap<String, Value>>,
1724        response_parameters: Option<&[&str]>,
1725        where_clause: Option<&str>,
1726    ) -> Result<Vec<HashMap<String, Value>>> {
1727        self.mqsc_command(
1728            "DISPLAY",
1729            "SERVICE",
1730            name,
1731            request_parameters,
1732            response_parameters,
1733            where_clause,
1734        )
1735    }
1736
1737    /// Execute the MQSC `DISPLAY SMDS` command.
1738    pub fn display_smds(
1739        &mut self,
1740        name: Option<&str>,
1741        request_parameters: Option<&HashMap<String, Value>>,
1742        response_parameters: Option<&[&str]>,
1743        where_clause: Option<&str>,
1744    ) -> Result<Vec<HashMap<String, Value>>> {
1745        self.mqsc_command(
1746            "DISPLAY",
1747            "SMDS",
1748            name,
1749            request_parameters,
1750            response_parameters,
1751            where_clause,
1752        )
1753    }
1754
1755    /// Execute the MQSC `DISPLAY SMDSCONN` command.
1756    pub fn display_smdsconn(
1757        &mut self,
1758        name: Option<&str>,
1759        request_parameters: Option<&HashMap<String, Value>>,
1760        response_parameters: Option<&[&str]>,
1761        where_clause: Option<&str>,
1762    ) -> Result<Vec<HashMap<String, Value>>> {
1763        self.mqsc_command(
1764            "DISPLAY",
1765            "SMDSCONN",
1766            name,
1767            request_parameters,
1768            response_parameters,
1769            where_clause,
1770        )
1771    }
1772
1773    /// Execute the MQSC `DISPLAY STGCLASS` command.
1774    pub fn display_stgclass(
1775        &mut self,
1776        name: Option<&str>,
1777        request_parameters: Option<&HashMap<String, Value>>,
1778        response_parameters: Option<&[&str]>,
1779        where_clause: Option<&str>,
1780    ) -> Result<Vec<HashMap<String, Value>>> {
1781        self.mqsc_command(
1782            "DISPLAY",
1783            "STGCLASS",
1784            name,
1785            request_parameters,
1786            response_parameters,
1787            where_clause,
1788        )
1789    }
1790
1791    /// Execute the MQSC `DISPLAY SUB` command.
1792    pub fn display_sub(
1793        &mut self,
1794        name: Option<&str>,
1795        request_parameters: Option<&HashMap<String, Value>>,
1796        response_parameters: Option<&[&str]>,
1797        where_clause: Option<&str>,
1798    ) -> Result<Vec<HashMap<String, Value>>> {
1799        self.mqsc_command(
1800            "DISPLAY",
1801            "SUB",
1802            name,
1803            request_parameters,
1804            response_parameters,
1805            where_clause,
1806        )
1807    }
1808
1809    /// Execute the MQSC `DISPLAY SVSTATUS` command.
1810    pub fn display_svstatus(
1811        &mut self,
1812        name: Option<&str>,
1813        request_parameters: Option<&HashMap<String, Value>>,
1814        response_parameters: Option<&[&str]>,
1815        where_clause: Option<&str>,
1816    ) -> Result<Vec<HashMap<String, Value>>> {
1817        self.mqsc_command(
1818            "DISPLAY",
1819            "SVSTATUS",
1820            name,
1821            request_parameters,
1822            response_parameters,
1823            where_clause,
1824        )
1825    }
1826
1827    /// Execute the MQSC `DISPLAY SYSTEM` command.
1828    pub fn display_system(
1829        &mut self,
1830        name: Option<&str>,
1831        request_parameters: Option<&HashMap<String, Value>>,
1832        response_parameters: Option<&[&str]>,
1833        where_clause: Option<&str>,
1834    ) -> Result<Vec<HashMap<String, Value>>> {
1835        self.mqsc_command(
1836            "DISPLAY",
1837            "SYSTEM",
1838            name,
1839            request_parameters,
1840            response_parameters,
1841            where_clause,
1842        )
1843    }
1844
1845    /// Execute the MQSC `DISPLAY TCLUSTER` command.
1846    pub fn display_tcluster(
1847        &mut self,
1848        name: Option<&str>,
1849        request_parameters: Option<&HashMap<String, Value>>,
1850        response_parameters: Option<&[&str]>,
1851        where_clause: Option<&str>,
1852    ) -> Result<Vec<HashMap<String, Value>>> {
1853        self.mqsc_command(
1854            "DISPLAY",
1855            "TCLUSTER",
1856            name,
1857            request_parameters,
1858            response_parameters,
1859            where_clause,
1860        )
1861    }
1862
1863    /// Execute the MQSC `DISPLAY THREAD` command.
1864    pub fn display_thread(
1865        &mut self,
1866        name: Option<&str>,
1867        request_parameters: Option<&HashMap<String, Value>>,
1868        response_parameters: Option<&[&str]>,
1869        where_clause: Option<&str>,
1870    ) -> Result<Vec<HashMap<String, Value>>> {
1871        self.mqsc_command(
1872            "DISPLAY",
1873            "THREAD",
1874            name,
1875            request_parameters,
1876            response_parameters,
1877            where_clause,
1878        )
1879    }
1880
1881    /// Execute the MQSC `DISPLAY TOPIC` command.
1882    pub fn display_topic(
1883        &mut self,
1884        name: Option<&str>,
1885        request_parameters: Option<&HashMap<String, Value>>,
1886        response_parameters: Option<&[&str]>,
1887        where_clause: Option<&str>,
1888    ) -> Result<Vec<HashMap<String, Value>>> {
1889        self.mqsc_command(
1890            "DISPLAY",
1891            "TOPIC",
1892            name,
1893            request_parameters,
1894            response_parameters,
1895            where_clause,
1896        )
1897    }
1898
1899    /// Execute the MQSC `DISPLAY TPSTATUS` command.
1900    pub fn display_tpstatus(
1901        &mut self,
1902        name: Option<&str>,
1903        request_parameters: Option<&HashMap<String, Value>>,
1904        response_parameters: Option<&[&str]>,
1905        where_clause: Option<&str>,
1906    ) -> Result<Vec<HashMap<String, Value>>> {
1907        self.mqsc_command(
1908            "DISPLAY",
1909            "TPSTATUS",
1910            name,
1911            request_parameters,
1912            response_parameters,
1913            where_clause,
1914        )
1915    }
1916
1917    /// Execute the MQSC `DISPLAY TRACE` command.
1918    pub fn display_trace(
1919        &mut self,
1920        name: Option<&str>,
1921        request_parameters: Option<&HashMap<String, Value>>,
1922        response_parameters: Option<&[&str]>,
1923        where_clause: Option<&str>,
1924    ) -> Result<Vec<HashMap<String, Value>>> {
1925        self.mqsc_command(
1926            "DISPLAY",
1927            "TRACE",
1928            name,
1929            request_parameters,
1930            response_parameters,
1931            where_clause,
1932        )
1933    }
1934
1935    /// Execute the MQSC `DISPLAY USAGE` command.
1936    pub fn display_usage(
1937        &mut self,
1938        name: Option<&str>,
1939        request_parameters: Option<&HashMap<String, Value>>,
1940        response_parameters: Option<&[&str]>,
1941        where_clause: Option<&str>,
1942    ) -> Result<Vec<HashMap<String, Value>>> {
1943        self.mqsc_command(
1944            "DISPLAY",
1945            "USAGE",
1946            name,
1947            request_parameters,
1948            response_parameters,
1949            where_clause,
1950        )
1951    }
1952
1953    /// Execute the MQSC `MOVE QLOCAL` command.
1954    pub fn move_qlocal(
1955        &mut self,
1956        name: Option<&str>,
1957        request_parameters: Option<&HashMap<String, Value>>,
1958        response_parameters: Option<&[&str]>,
1959    ) -> Result<()> {
1960        self.mqsc_command(
1961            "MOVE",
1962            "QLOCAL",
1963            name,
1964            request_parameters,
1965            response_parameters,
1966            None,
1967        )?;
1968        Ok(())
1969    }
1970
1971    /// Execute the MQSC `PING CHANNEL` command.
1972    pub fn ping_channel(
1973        &mut self,
1974        name: Option<&str>,
1975        request_parameters: Option<&HashMap<String, Value>>,
1976        response_parameters: Option<&[&str]>,
1977    ) -> Result<()> {
1978        self.mqsc_command(
1979            "PING",
1980            "CHANNEL",
1981            name,
1982            request_parameters,
1983            response_parameters,
1984            None,
1985        )?;
1986        Ok(())
1987    }
1988
1989    /// Execute the MQSC `PING QMGR` command.
1990    pub fn ping_qmgr(
1991        &mut self,
1992        request_parameters: Option<&HashMap<String, Value>>,
1993        response_parameters: Option<&[&str]>,
1994    ) -> Result<()> {
1995        self.mqsc_command(
1996            "PING",
1997            "QMGR",
1998            None,
1999            request_parameters,
2000            response_parameters,
2001            None,
2002        )?;
2003        Ok(())
2004    }
2005
2006    /// Execute the MQSC `PURGE CHANNEL` command.
2007    pub fn purge_channel(
2008        &mut self,
2009        name: Option<&str>,
2010        request_parameters: Option<&HashMap<String, Value>>,
2011        response_parameters: Option<&[&str]>,
2012    ) -> Result<()> {
2013        self.mqsc_command(
2014            "PURGE",
2015            "CHANNEL",
2016            name,
2017            request_parameters,
2018            response_parameters,
2019            None,
2020        )?;
2021        Ok(())
2022    }
2023
2024    /// Execute the MQSC `RECOVER BSDS` command.
2025    pub fn recover_bsds(
2026        &mut self,
2027        name: Option<&str>,
2028        request_parameters: Option<&HashMap<String, Value>>,
2029        response_parameters: Option<&[&str]>,
2030    ) -> Result<()> {
2031        self.mqsc_command(
2032            "RECOVER",
2033            "BSDS",
2034            name,
2035            request_parameters,
2036            response_parameters,
2037            None,
2038        )?;
2039        Ok(())
2040    }
2041
2042    /// Execute the MQSC `RECOVER CFSTRUCT` command.
2043    pub fn recover_cfstruct(
2044        &mut self,
2045        name: Option<&str>,
2046        request_parameters: Option<&HashMap<String, Value>>,
2047        response_parameters: Option<&[&str]>,
2048    ) -> Result<()> {
2049        self.mqsc_command(
2050            "RECOVER",
2051            "CFSTRUCT",
2052            name,
2053            request_parameters,
2054            response_parameters,
2055            None,
2056        )?;
2057        Ok(())
2058    }
2059
2060    /// Execute the MQSC `REFRESH CLUSTER` command.
2061    pub fn refresh_cluster(
2062        &mut self,
2063        name: Option<&str>,
2064        request_parameters: Option<&HashMap<String, Value>>,
2065        response_parameters: Option<&[&str]>,
2066    ) -> Result<()> {
2067        self.mqsc_command(
2068            "REFRESH",
2069            "CLUSTER",
2070            name,
2071            request_parameters,
2072            response_parameters,
2073            None,
2074        )?;
2075        Ok(())
2076    }
2077
2078    /// Execute the MQSC `REFRESH QMGR` command.
2079    pub fn refresh_qmgr(
2080        &mut self,
2081        request_parameters: Option<&HashMap<String, Value>>,
2082        response_parameters: Option<&[&str]>,
2083    ) -> Result<()> {
2084        self.mqsc_command(
2085            "REFRESH",
2086            "QMGR",
2087            None,
2088            request_parameters,
2089            response_parameters,
2090            None,
2091        )?;
2092        Ok(())
2093    }
2094
2095    /// Execute the MQSC `REFRESH SECURITY` command.
2096    pub fn refresh_security(
2097        &mut self,
2098        name: Option<&str>,
2099        request_parameters: Option<&HashMap<String, Value>>,
2100        response_parameters: Option<&[&str]>,
2101    ) -> Result<()> {
2102        self.mqsc_command(
2103            "REFRESH",
2104            "SECURITY",
2105            name,
2106            request_parameters,
2107            response_parameters,
2108            None,
2109        )?;
2110        Ok(())
2111    }
2112
2113    /// Execute the MQSC `RESET CFSTRUCT` command.
2114    pub fn reset_cfstruct(
2115        &mut self,
2116        name: Option<&str>,
2117        request_parameters: Option<&HashMap<String, Value>>,
2118        response_parameters: Option<&[&str]>,
2119    ) -> Result<()> {
2120        self.mqsc_command(
2121            "RESET",
2122            "CFSTRUCT",
2123            name,
2124            request_parameters,
2125            response_parameters,
2126            None,
2127        )?;
2128        Ok(())
2129    }
2130
2131    /// Execute the MQSC `RESET CHANNEL` command.
2132    pub fn reset_channel(
2133        &mut self,
2134        name: Option<&str>,
2135        request_parameters: Option<&HashMap<String, Value>>,
2136        response_parameters: Option<&[&str]>,
2137    ) -> Result<()> {
2138        self.mqsc_command(
2139            "RESET",
2140            "CHANNEL",
2141            name,
2142            request_parameters,
2143            response_parameters,
2144            None,
2145        )?;
2146        Ok(())
2147    }
2148
2149    /// Execute the MQSC `RESET CLUSTER` command.
2150    pub fn reset_cluster(
2151        &mut self,
2152        name: Option<&str>,
2153        request_parameters: Option<&HashMap<String, Value>>,
2154        response_parameters: Option<&[&str]>,
2155    ) -> Result<()> {
2156        self.mqsc_command(
2157            "RESET",
2158            "CLUSTER",
2159            name,
2160            request_parameters,
2161            response_parameters,
2162            None,
2163        )?;
2164        Ok(())
2165    }
2166
2167    /// Execute the MQSC `RESET QMGR` command.
2168    pub fn reset_qmgr(
2169        &mut self,
2170        request_parameters: Option<&HashMap<String, Value>>,
2171        response_parameters: Option<&[&str]>,
2172    ) -> Result<()> {
2173        self.mqsc_command(
2174            "RESET",
2175            "QMGR",
2176            None,
2177            request_parameters,
2178            response_parameters,
2179            None,
2180        )?;
2181        Ok(())
2182    }
2183
2184    /// Execute the MQSC `RESET QSTATS` command.
2185    pub fn reset_qstats(
2186        &mut self,
2187        name: Option<&str>,
2188        request_parameters: Option<&HashMap<String, Value>>,
2189        response_parameters: Option<&[&str]>,
2190    ) -> Result<()> {
2191        self.mqsc_command(
2192            "RESET",
2193            "QSTATS",
2194            name,
2195            request_parameters,
2196            response_parameters,
2197            None,
2198        )?;
2199        Ok(())
2200    }
2201
2202    /// Execute the MQSC `RESET SMDS` command.
2203    pub fn reset_smds(
2204        &mut self,
2205        name: Option<&str>,
2206        request_parameters: Option<&HashMap<String, Value>>,
2207        response_parameters: Option<&[&str]>,
2208    ) -> Result<()> {
2209        self.mqsc_command(
2210            "RESET",
2211            "SMDS",
2212            name,
2213            request_parameters,
2214            response_parameters,
2215            None,
2216        )?;
2217        Ok(())
2218    }
2219
2220    /// Execute the MQSC `RESET TPIPE` command.
2221    pub fn reset_tpipe(
2222        &mut self,
2223        name: Option<&str>,
2224        request_parameters: Option<&HashMap<String, Value>>,
2225        response_parameters: Option<&[&str]>,
2226    ) -> Result<()> {
2227        self.mqsc_command(
2228            "RESET",
2229            "TPIPE",
2230            name,
2231            request_parameters,
2232            response_parameters,
2233            None,
2234        )?;
2235        Ok(())
2236    }
2237
2238    /// Execute the MQSC `RESOLVE CHANNEL` command.
2239    pub fn resolve_channel(
2240        &mut self,
2241        name: Option<&str>,
2242        request_parameters: Option<&HashMap<String, Value>>,
2243        response_parameters: Option<&[&str]>,
2244    ) -> Result<()> {
2245        self.mqsc_command(
2246            "RESOLVE",
2247            "CHANNEL",
2248            name,
2249            request_parameters,
2250            response_parameters,
2251            None,
2252        )?;
2253        Ok(())
2254    }
2255
2256    /// Execute the MQSC `RESOLVE INDOUBT` command.
2257    pub fn resolve_indoubt(
2258        &mut self,
2259        name: Option<&str>,
2260        request_parameters: Option<&HashMap<String, Value>>,
2261        response_parameters: Option<&[&str]>,
2262    ) -> Result<()> {
2263        self.mqsc_command(
2264            "RESOLVE",
2265            "INDOUBT",
2266            name,
2267            request_parameters,
2268            response_parameters,
2269            None,
2270        )?;
2271        Ok(())
2272    }
2273
2274    /// Execute the MQSC `RESUME QMGR` command.
2275    pub fn resume_qmgr(
2276        &mut self,
2277        request_parameters: Option<&HashMap<String, Value>>,
2278        response_parameters: Option<&[&str]>,
2279    ) -> Result<()> {
2280        self.mqsc_command(
2281            "RESUME",
2282            "QMGR",
2283            None,
2284            request_parameters,
2285            response_parameters,
2286            None,
2287        )?;
2288        Ok(())
2289    }
2290
2291    /// Execute the MQSC `RVERIFY SECURITY` command.
2292    pub fn rverify_security(
2293        &mut self,
2294        name: Option<&str>,
2295        request_parameters: Option<&HashMap<String, Value>>,
2296        response_parameters: Option<&[&str]>,
2297    ) -> Result<()> {
2298        self.mqsc_command(
2299            "RVERIFY",
2300            "SECURITY",
2301            name,
2302            request_parameters,
2303            response_parameters,
2304            None,
2305        )?;
2306        Ok(())
2307    }
2308
2309    /// Execute the MQSC `SET ARCHIVE` command.
2310    pub fn set_archive(
2311        &mut self,
2312        name: Option<&str>,
2313        request_parameters: Option<&HashMap<String, Value>>,
2314        response_parameters: Option<&[&str]>,
2315    ) -> Result<()> {
2316        self.mqsc_command(
2317            "SET",
2318            "ARCHIVE",
2319            name,
2320            request_parameters,
2321            response_parameters,
2322            None,
2323        )?;
2324        Ok(())
2325    }
2326
2327    /// Execute the MQSC `SET AUTHREC` command.
2328    pub fn set_authrec(
2329        &mut self,
2330        name: Option<&str>,
2331        request_parameters: Option<&HashMap<String, Value>>,
2332        response_parameters: Option<&[&str]>,
2333    ) -> Result<()> {
2334        self.mqsc_command(
2335            "SET",
2336            "AUTHREC",
2337            name,
2338            request_parameters,
2339            response_parameters,
2340            None,
2341        )?;
2342        Ok(())
2343    }
2344
2345    /// Execute the MQSC `SET CHLAUTH` command.
2346    pub fn set_chlauth(
2347        &mut self,
2348        name: Option<&str>,
2349        request_parameters: Option<&HashMap<String, Value>>,
2350        response_parameters: Option<&[&str]>,
2351    ) -> Result<()> {
2352        self.mqsc_command(
2353            "SET",
2354            "CHLAUTH",
2355            name,
2356            request_parameters,
2357            response_parameters,
2358            None,
2359        )?;
2360        Ok(())
2361    }
2362
2363    /// Execute the MQSC `SET LOG` command.
2364    pub fn set_log(
2365        &mut self,
2366        name: Option<&str>,
2367        request_parameters: Option<&HashMap<String, Value>>,
2368        response_parameters: Option<&[&str]>,
2369    ) -> Result<()> {
2370        self.mqsc_command(
2371            "SET",
2372            "LOG",
2373            name,
2374            request_parameters,
2375            response_parameters,
2376            None,
2377        )?;
2378        Ok(())
2379    }
2380
2381    /// Execute the MQSC `SET POLICY` command.
2382    pub fn set_policy(
2383        &mut self,
2384        name: Option<&str>,
2385        request_parameters: Option<&HashMap<String, Value>>,
2386        response_parameters: Option<&[&str]>,
2387    ) -> Result<()> {
2388        self.mqsc_command(
2389            "SET",
2390            "POLICY",
2391            name,
2392            request_parameters,
2393            response_parameters,
2394            None,
2395        )?;
2396        Ok(())
2397    }
2398
2399    /// Execute the MQSC `SET SYSTEM` command.
2400    pub fn set_system(
2401        &mut self,
2402        name: Option<&str>,
2403        request_parameters: Option<&HashMap<String, Value>>,
2404        response_parameters: Option<&[&str]>,
2405    ) -> Result<()> {
2406        self.mqsc_command(
2407            "SET",
2408            "SYSTEM",
2409            name,
2410            request_parameters,
2411            response_parameters,
2412            None,
2413        )?;
2414        Ok(())
2415    }
2416
2417    /// Execute the MQSC `START CHANNEL` command.
2418    pub fn start_channel(
2419        &mut self,
2420        name: Option<&str>,
2421        request_parameters: Option<&HashMap<String, Value>>,
2422        response_parameters: Option<&[&str]>,
2423    ) -> Result<()> {
2424        self.mqsc_command(
2425            "START",
2426            "CHANNEL",
2427            name,
2428            request_parameters,
2429            response_parameters,
2430            None,
2431        )?;
2432        Ok(())
2433    }
2434
2435    /// Execute the MQSC `START CHINIT` command.
2436    pub fn start_chinit(
2437        &mut self,
2438        name: Option<&str>,
2439        request_parameters: Option<&HashMap<String, Value>>,
2440        response_parameters: Option<&[&str]>,
2441    ) -> Result<()> {
2442        self.mqsc_command(
2443            "START",
2444            "CHINIT",
2445            name,
2446            request_parameters,
2447            response_parameters,
2448            None,
2449        )?;
2450        Ok(())
2451    }
2452
2453    /// Execute the MQSC `START CMDSERV` command.
2454    pub fn start_cmdserv(
2455        &mut self,
2456        request_parameters: Option<&HashMap<String, Value>>,
2457        response_parameters: Option<&[&str]>,
2458    ) -> Result<()> {
2459        self.mqsc_command(
2460            "START",
2461            "CMDSERV",
2462            None,
2463            request_parameters,
2464            response_parameters,
2465            None,
2466        )?;
2467        Ok(())
2468    }
2469
2470    /// Execute the MQSC `START LISTENER` command.
2471    pub fn start_listener(
2472        &mut self,
2473        name: Option<&str>,
2474        request_parameters: Option<&HashMap<String, Value>>,
2475        response_parameters: Option<&[&str]>,
2476    ) -> Result<()> {
2477        self.mqsc_command(
2478            "START",
2479            "LISTENER",
2480            name,
2481            request_parameters,
2482            response_parameters,
2483            None,
2484        )?;
2485        Ok(())
2486    }
2487
2488    /// Execute the MQSC `START QMGR` command.
2489    pub fn start_qmgr(
2490        &mut self,
2491        request_parameters: Option<&HashMap<String, Value>>,
2492        response_parameters: Option<&[&str]>,
2493    ) -> Result<()> {
2494        self.mqsc_command(
2495            "START",
2496            "QMGR",
2497            None,
2498            request_parameters,
2499            response_parameters,
2500            None,
2501        )?;
2502        Ok(())
2503    }
2504
2505    /// Execute the MQSC `START SERVICE` command.
2506    pub fn start_service(
2507        &mut self,
2508        name: Option<&str>,
2509        request_parameters: Option<&HashMap<String, Value>>,
2510        response_parameters: Option<&[&str]>,
2511    ) -> Result<()> {
2512        self.mqsc_command(
2513            "START",
2514            "SERVICE",
2515            name,
2516            request_parameters,
2517            response_parameters,
2518            None,
2519        )?;
2520        Ok(())
2521    }
2522
2523    /// Execute the MQSC `START SMDSCONN` command.
2524    pub fn start_smdsconn(
2525        &mut self,
2526        name: Option<&str>,
2527        request_parameters: Option<&HashMap<String, Value>>,
2528        response_parameters: Option<&[&str]>,
2529    ) -> Result<()> {
2530        self.mqsc_command(
2531            "START",
2532            "SMDSCONN",
2533            name,
2534            request_parameters,
2535            response_parameters,
2536            None,
2537        )?;
2538        Ok(())
2539    }
2540
2541    /// Execute the MQSC `START TRACE` command.
2542    pub fn start_trace(
2543        &mut self,
2544        name: Option<&str>,
2545        request_parameters: Option<&HashMap<String, Value>>,
2546        response_parameters: Option<&[&str]>,
2547    ) -> Result<()> {
2548        self.mqsc_command(
2549            "START",
2550            "TRACE",
2551            name,
2552            request_parameters,
2553            response_parameters,
2554            None,
2555        )?;
2556        Ok(())
2557    }
2558
2559    /// Execute the MQSC `STOP CHANNEL` command.
2560    pub fn stop_channel(
2561        &mut self,
2562        name: Option<&str>,
2563        request_parameters: Option<&HashMap<String, Value>>,
2564        response_parameters: Option<&[&str]>,
2565    ) -> Result<()> {
2566        self.mqsc_command(
2567            "STOP",
2568            "CHANNEL",
2569            name,
2570            request_parameters,
2571            response_parameters,
2572            None,
2573        )?;
2574        Ok(())
2575    }
2576
2577    /// Execute the MQSC `STOP CHINIT` command.
2578    pub fn stop_chinit(
2579        &mut self,
2580        name: Option<&str>,
2581        request_parameters: Option<&HashMap<String, Value>>,
2582        response_parameters: Option<&[&str]>,
2583    ) -> Result<()> {
2584        self.mqsc_command(
2585            "STOP",
2586            "CHINIT",
2587            name,
2588            request_parameters,
2589            response_parameters,
2590            None,
2591        )?;
2592        Ok(())
2593    }
2594
2595    /// Execute the MQSC `STOP CMDSERV` command.
2596    pub fn stop_cmdserv(
2597        &mut self,
2598        request_parameters: Option<&HashMap<String, Value>>,
2599        response_parameters: Option<&[&str]>,
2600    ) -> Result<()> {
2601        self.mqsc_command(
2602            "STOP",
2603            "CMDSERV",
2604            None,
2605            request_parameters,
2606            response_parameters,
2607            None,
2608        )?;
2609        Ok(())
2610    }
2611
2612    /// Execute the MQSC `STOP CONN` command.
2613    pub fn stop_conn(
2614        &mut self,
2615        name: Option<&str>,
2616        request_parameters: Option<&HashMap<String, Value>>,
2617        response_parameters: Option<&[&str]>,
2618    ) -> Result<()> {
2619        self.mqsc_command(
2620            "STOP",
2621            "CONN",
2622            name,
2623            request_parameters,
2624            response_parameters,
2625            None,
2626        )?;
2627        Ok(())
2628    }
2629
2630    /// Execute the MQSC `STOP LISTENER` command.
2631    pub fn stop_listener(
2632        &mut self,
2633        name: Option<&str>,
2634        request_parameters: Option<&HashMap<String, Value>>,
2635        response_parameters: Option<&[&str]>,
2636    ) -> Result<()> {
2637        self.mqsc_command(
2638            "STOP",
2639            "LISTENER",
2640            name,
2641            request_parameters,
2642            response_parameters,
2643            None,
2644        )?;
2645        Ok(())
2646    }
2647
2648    /// Execute the MQSC `STOP QMGR` command.
2649    pub fn stop_qmgr(
2650        &mut self,
2651        request_parameters: Option<&HashMap<String, Value>>,
2652        response_parameters: Option<&[&str]>,
2653    ) -> Result<()> {
2654        self.mqsc_command(
2655            "STOP",
2656            "QMGR",
2657            None,
2658            request_parameters,
2659            response_parameters,
2660            None,
2661        )?;
2662        Ok(())
2663    }
2664
2665    /// Execute the MQSC `STOP SERVICE` command.
2666    pub fn stop_service(
2667        &mut self,
2668        name: Option<&str>,
2669        request_parameters: Option<&HashMap<String, Value>>,
2670        response_parameters: Option<&[&str]>,
2671    ) -> Result<()> {
2672        self.mqsc_command(
2673            "STOP",
2674            "SERVICE",
2675            name,
2676            request_parameters,
2677            response_parameters,
2678            None,
2679        )?;
2680        Ok(())
2681    }
2682
2683    /// Execute the MQSC `STOP SMDSCONN` command.
2684    pub fn stop_smdsconn(
2685        &mut self,
2686        name: Option<&str>,
2687        request_parameters: Option<&HashMap<String, Value>>,
2688        response_parameters: Option<&[&str]>,
2689    ) -> Result<()> {
2690        self.mqsc_command(
2691            "STOP",
2692            "SMDSCONN",
2693            name,
2694            request_parameters,
2695            response_parameters,
2696            None,
2697        )?;
2698        Ok(())
2699    }
2700
2701    /// Execute the MQSC `STOP TRACE` command.
2702    pub fn stop_trace(
2703        &mut self,
2704        name: Option<&str>,
2705        request_parameters: Option<&HashMap<String, Value>>,
2706        response_parameters: Option<&[&str]>,
2707    ) -> Result<()> {
2708        self.mqsc_command(
2709            "STOP",
2710            "TRACE",
2711            name,
2712            request_parameters,
2713            response_parameters,
2714            None,
2715        )?;
2716        Ok(())
2717    }
2718
2719    /// Execute the MQSC `SUSPEND QMGR` command.
2720    pub fn suspend_qmgr(
2721        &mut self,
2722        request_parameters: Option<&HashMap<String, Value>>,
2723        response_parameters: Option<&[&str]>,
2724    ) -> Result<()> {
2725        self.mqsc_command(
2726            "SUSPEND",
2727            "QMGR",
2728            None,
2729            request_parameters,
2730            response_parameters,
2731            None,
2732        )?;
2733        Ok(())
2734    }
2735
2736    // END GENERATED MQSC METHODS
2737}
2738
2739#[cfg(test)]
2740mod tests {
2741    use super::*;
2742    use crate::test_helpers::{
2743        MockTransport, empty_success_response, mock_session, success_response,
2744    };
2745    use serde_json::json;
2746
2747    // -----------------------------------------------------------------
2748    // Macro: Pattern 1 — Singleton DISPLAY (returns Option)
2749    // -----------------------------------------------------------------
2750    macro_rules! test_singleton_display {
2751        ($method:ident) => {
2752            paste::paste! {
2753                #[test]
2754                fn [<test_ $method _returns_option>]() {
2755                    let transport = MockTransport::new(vec![empty_success_response()]);
2756                    let mut session = mock_session(transport);
2757                    let result = session.$method(None, None).unwrap();
2758                    assert!(result.is_none());
2759                }
2760
2761                #[test]
2762                fn [<test_ $method _error_propagates>]() {
2763                    let transport = MockTransport::new(vec![]);
2764                    let mut session = mock_session(transport);
2765                    assert!(session.$method(None, None).is_err());
2766                }
2767            }
2768        };
2769    }
2770
2771    test_singleton_display!(display_qmgr);
2772    test_singleton_display!(display_qmstatus);
2773    test_singleton_display!(display_cmdserv);
2774
2775    // -----------------------------------------------------------------
2776    // Macro: Pattern 2 — List DISPLAY (returns Vec)
2777    // -----------------------------------------------------------------
2778    macro_rules! test_list_display {
2779        ($method:ident) => {
2780            paste::paste! {
2781                #[test]
2782                fn [<test_ $method _returns_vec>]() {
2783                    let transport = MockTransport::new(vec![empty_success_response()]);
2784                    let mut session = mock_session(transport);
2785                    let result = session.$method(None, None, None, None).unwrap();
2786                    assert!(result.is_empty());
2787                }
2788
2789                #[test]
2790                fn [<test_ $method _error_propagates>]() {
2791                    let transport = MockTransport::new(vec![]);
2792                    let mut session = mock_session(transport);
2793                    assert!(session.$method(None, None, None, None).is_err());
2794                }
2795            }
2796        };
2797    }
2798
2799    test_list_display!(display_queue);
2800    test_list_display!(display_channel);
2801    test_list_display!(display_apstatus);
2802    test_list_display!(display_archive);
2803    test_list_display!(display_authinfo);
2804    test_list_display!(display_authrec);
2805    test_list_display!(display_authserv);
2806    test_list_display!(display_cfstatus);
2807    test_list_display!(display_cfstruct);
2808    test_list_display!(display_chinit);
2809    test_list_display!(display_chlauth);
2810    test_list_display!(display_chstatus);
2811    test_list_display!(display_clusqmgr);
2812    test_list_display!(display_comminfo);
2813    test_list_display!(display_conn);
2814    test_list_display!(display_entauth);
2815    test_list_display!(display_group);
2816    test_list_display!(display_listener);
2817    test_list_display!(display_log);
2818    test_list_display!(display_lsstatus);
2819    test_list_display!(display_maxsmsgs);
2820    test_list_display!(display_namelist);
2821    test_list_display!(display_policy);
2822    test_list_display!(display_process);
2823    test_list_display!(display_pubsub);
2824    test_list_display!(display_qstatus);
2825    test_list_display!(display_sbstatus);
2826    test_list_display!(display_security);
2827    test_list_display!(display_service);
2828    test_list_display!(display_smds);
2829    test_list_display!(display_smdsconn);
2830    test_list_display!(display_stgclass);
2831    test_list_display!(display_sub);
2832    test_list_display!(display_svstatus);
2833    test_list_display!(display_system);
2834    test_list_display!(display_tcluster);
2835    test_list_display!(display_thread);
2836    test_list_display!(display_topic);
2837    test_list_display!(display_tpstatus);
2838    test_list_display!(display_trace);
2839    test_list_display!(display_usage);
2840
2841    // -----------------------------------------------------------------
2842    // Macro: Pattern 3a — Mutating with required name (&str)
2843    // -----------------------------------------------------------------
2844    macro_rules! test_mutating_required_name {
2845        ($method:ident) => {
2846            paste::paste! {
2847                #[test]
2848                fn [<test_ $method _ok>]() {
2849                    let transport = MockTransport::new(vec![empty_success_response()]);
2850                    let mut session = mock_session(transport);
2851                    session.$method("OBJ1", None, None).unwrap();
2852                }
2853
2854                #[test]
2855                fn [<test_ $method _error_propagates>]() {
2856                    let transport = MockTransport::new(vec![]);
2857                    let mut session = mock_session(transport);
2858                    assert!(session.$method("OBJ1", None, None).is_err());
2859                }
2860            }
2861        };
2862    }
2863
2864    test_mutating_required_name!(define_qlocal);
2865    test_mutating_required_name!(define_qremote);
2866    test_mutating_required_name!(define_qalias);
2867    test_mutating_required_name!(define_qmodel);
2868    test_mutating_required_name!(define_channel);
2869    test_mutating_required_name!(delete_channel);
2870    test_mutating_required_name!(delete_qalias);
2871    test_mutating_required_name!(delete_qlocal);
2872    test_mutating_required_name!(delete_qmodel);
2873    test_mutating_required_name!(delete_qremote);
2874    test_mutating_required_name!(delete_queue);
2875
2876    // -----------------------------------------------------------------
2877    // Macro: Pattern 3a — Mutating with optional name (Option<&str>)
2878    // -----------------------------------------------------------------
2879    macro_rules! test_mutating_optional_name {
2880        ($method:ident) => {
2881            paste::paste! {
2882                #[test]
2883                fn [<test_ $method _ok>]() {
2884                    let transport = MockTransport::new(vec![empty_success_response()]);
2885                    let mut session = mock_session(transport);
2886                    session.$method(Some("OBJ1"), None, None).unwrap();
2887                }
2888
2889                #[test]
2890                fn [<test_ $method _error_propagates>]() {
2891                    let transport = MockTransport::new(vec![]);
2892                    let mut session = mock_session(transport);
2893                    assert!(session.$method(Some("OBJ1"), None, None).is_err());
2894                }
2895            }
2896        };
2897    }
2898
2899    test_mutating_optional_name!(alter_authinfo);
2900    test_mutating_optional_name!(alter_buffpool);
2901    test_mutating_optional_name!(alter_cfstruct);
2902    test_mutating_optional_name!(alter_channel);
2903    test_mutating_optional_name!(alter_comminfo);
2904    test_mutating_optional_name!(alter_listener);
2905    test_mutating_optional_name!(alter_namelist);
2906    test_mutating_optional_name!(alter_process);
2907    test_mutating_optional_name!(alter_psid);
2908    test_mutating_optional_name!(alter_security);
2909    test_mutating_optional_name!(alter_service);
2910    test_mutating_optional_name!(alter_smds);
2911    test_mutating_optional_name!(alter_stgclass);
2912    test_mutating_optional_name!(alter_sub);
2913    test_mutating_optional_name!(alter_topic);
2914    test_mutating_optional_name!(alter_qalias);
2915    test_mutating_optional_name!(alter_qlocal);
2916    test_mutating_optional_name!(alter_qmodel);
2917    test_mutating_optional_name!(alter_qremote);
2918    test_mutating_optional_name!(alter_trace);
2919    test_mutating_optional_name!(archive_log);
2920    test_mutating_optional_name!(backup_cfstruct);
2921    test_mutating_optional_name!(clear_qlocal);
2922    test_mutating_optional_name!(clear_topicstr);
2923    test_mutating_optional_name!(define_authinfo);
2924    test_mutating_optional_name!(define_buffpool);
2925    test_mutating_optional_name!(define_cfstruct);
2926    test_mutating_optional_name!(define_comminfo);
2927    test_mutating_optional_name!(define_listener);
2928    test_mutating_optional_name!(define_log);
2929    test_mutating_optional_name!(define_maxsmsgs);
2930    test_mutating_optional_name!(define_namelist);
2931    test_mutating_optional_name!(define_process);
2932    test_mutating_optional_name!(define_psid);
2933    test_mutating_optional_name!(define_service);
2934    test_mutating_optional_name!(define_stgclass);
2935    test_mutating_optional_name!(define_sub);
2936    test_mutating_optional_name!(define_topic);
2937    test_mutating_optional_name!(delete_authinfo);
2938    test_mutating_optional_name!(delete_authrec);
2939    test_mutating_optional_name!(delete_buffpool);
2940    test_mutating_optional_name!(delete_cfstruct);
2941    test_mutating_optional_name!(delete_comminfo);
2942    test_mutating_optional_name!(delete_listener);
2943    test_mutating_optional_name!(delete_namelist);
2944    test_mutating_optional_name!(delete_policy);
2945    test_mutating_optional_name!(delete_process);
2946    test_mutating_optional_name!(delete_psid);
2947    test_mutating_optional_name!(delete_service);
2948    test_mutating_optional_name!(delete_stgclass);
2949    test_mutating_optional_name!(delete_sub);
2950    test_mutating_optional_name!(delete_topic);
2951    test_mutating_optional_name!(move_qlocal);
2952    test_mutating_optional_name!(ping_channel);
2953    test_mutating_optional_name!(purge_channel);
2954    test_mutating_optional_name!(recover_bsds);
2955    test_mutating_optional_name!(recover_cfstruct);
2956    test_mutating_optional_name!(refresh_cluster);
2957    test_mutating_optional_name!(refresh_security);
2958    test_mutating_optional_name!(reset_cfstruct);
2959    test_mutating_optional_name!(reset_channel);
2960    test_mutating_optional_name!(reset_cluster);
2961    test_mutating_optional_name!(reset_qstats);
2962    test_mutating_optional_name!(reset_smds);
2963    test_mutating_optional_name!(reset_tpipe);
2964    test_mutating_optional_name!(resolve_channel);
2965    test_mutating_optional_name!(resolve_indoubt);
2966    test_mutating_optional_name!(rverify_security);
2967    test_mutating_optional_name!(set_archive);
2968    test_mutating_optional_name!(set_authrec);
2969    test_mutating_optional_name!(set_chlauth);
2970    test_mutating_optional_name!(set_log);
2971    test_mutating_optional_name!(set_policy);
2972    test_mutating_optional_name!(set_system);
2973    test_mutating_optional_name!(start_channel);
2974    test_mutating_optional_name!(start_chinit);
2975    test_mutating_optional_name!(start_listener);
2976    test_mutating_optional_name!(start_service);
2977    test_mutating_optional_name!(start_smdsconn);
2978    test_mutating_optional_name!(start_trace);
2979    test_mutating_optional_name!(stop_channel);
2980    test_mutating_optional_name!(stop_chinit);
2981    test_mutating_optional_name!(stop_conn);
2982    test_mutating_optional_name!(stop_listener);
2983    test_mutating_optional_name!(stop_service);
2984    test_mutating_optional_name!(stop_smdsconn);
2985    test_mutating_optional_name!(stop_trace);
2986
2987    // -----------------------------------------------------------------
2988    // Macro: Pattern 3b — Mutating without name
2989    // -----------------------------------------------------------------
2990    macro_rules! test_mutating_no_name {
2991        ($method:ident) => {
2992            paste::paste! {
2993                #[test]
2994                fn [<test_ $method _ok>]() {
2995                    let transport = MockTransport::new(vec![empty_success_response()]);
2996                    let mut session = mock_session(transport);
2997                    session.$method(None, None).unwrap();
2998                }
2999
3000                #[test]
3001                fn [<test_ $method _error_propagates>]() {
3002                    let transport = MockTransport::new(vec![]);
3003                    let mut session = mock_session(transport);
3004                    assert!(session.$method(None, None).is_err());
3005                }
3006            }
3007        };
3008    }
3009
3010    test_mutating_no_name!(alter_qmgr);
3011    test_mutating_no_name!(ping_qmgr);
3012    test_mutating_no_name!(refresh_qmgr);
3013    test_mutating_no_name!(reset_qmgr);
3014    test_mutating_no_name!(resume_qmgr);
3015    test_mutating_no_name!(start_cmdserv);
3016    test_mutating_no_name!(start_qmgr);
3017    test_mutating_no_name!(stop_cmdserv);
3018    test_mutating_no_name!(stop_qmgr);
3019    test_mutating_no_name!(suspend_qmgr);
3020
3021    // -----------------------------------------------------------------
3022    // Hand-crafted tests for command/qualifier verification
3023    // -----------------------------------------------------------------
3024
3025    #[test]
3026    fn display_queue_sends_correct_command() {
3027        let mut params = HashMap::new();
3028        params.insert("DESCR".into(), json!("test"));
3029        let transport = MockTransport::new(vec![success_response(vec![params])]);
3030        let mut session = mock_session(transport);
3031        session.display_queue(Some("Q1"), None, None, None).unwrap();
3032        let payload = session.last_command_payload.unwrap();
3033        assert_eq!(payload["command"], json!("DISPLAY"));
3034        assert_eq!(payload["qualifier"], json!("QUEUE"));
3035        assert_eq!(payload["name"], json!("Q1"));
3036    }
3037
3038    #[test]
3039    fn define_qlocal_sends_correct_command() {
3040        let transport = MockTransport::new(vec![empty_success_response()]);
3041        let mut session = mock_session(transport);
3042        session.define_qlocal("MY.Q", None, None).unwrap();
3043        let payload = session.last_command_payload.unwrap();
3044        assert_eq!(payload["command"], json!("DEFINE"));
3045        assert_eq!(payload["qualifier"], json!("QLOCAL"));
3046        assert_eq!(payload["name"], json!("MY.Q"));
3047    }
3048
3049    #[test]
3050    fn alter_qmgr_sends_correct_command() {
3051        let transport = MockTransport::new(vec![empty_success_response()]);
3052        let mut session = mock_session(transport);
3053        session.alter_qmgr(None, None).unwrap();
3054        let payload = session.last_command_payload.unwrap();
3055        assert_eq!(payload["command"], json!("ALTER"));
3056        assert_eq!(payload["qualifier"], json!("QMGR"));
3057        assert!(!payload.contains_key("name"));
3058    }
3059
3060    #[test]
3061    fn display_queue_default_name_wildcard() {
3062        let transport = MockTransport::new(vec![empty_success_response()]);
3063        let mut session = mock_session(transport);
3064        session.display_queue(None, None, None, None).unwrap();
3065        let payload = session.last_command_payload.unwrap();
3066        assert_eq!(payload["name"], json!("*"));
3067    }
3068
3069    #[test]
3070    fn singleton_display_returns_some_when_present() {
3071        let mut params = HashMap::new();
3072        params.insert("QMNAME".into(), json!("QM1"));
3073        let transport = MockTransport::new(vec![success_response(vec![params])]);
3074        let mut session = mock_session(transport);
3075        let result = session.display_qmgr(None, None).unwrap();
3076        assert!(result.is_some());
3077        assert_eq!(result.unwrap()["QMNAME"], json!("QM1"));
3078    }
3079}