@smartbear/mcp 0.27.2 → 0.29.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/bearq/client.js +5 -3
- package/dist/bearq/tool/environments/list-environments.js +28 -0
- package/dist/bearq/tool/tasks/run-regression-tests.js +10 -3
- package/dist/bearq/tool/tasks/run-test-cases.js +12 -3
- package/dist/bearq/tool/tasks/run-tests-in-functional-areas.js +12 -3
- package/dist/bugsnag/client.js +2 -2
- package/dist/collaborator/client.js +5 -2
- package/dist/common/client-identity.js +20 -0
- package/dist/common/info.js +21 -1
- package/dist/common/initialize.js +29 -0
- package/dist/common/request-context.js +7 -0
- package/dist/common/server.js +39 -0
- package/dist/common/transport-http.js +15 -26
- package/dist/common/transport-stdio.js +2 -13
- package/dist/package.json.js +1 -1
- package/dist/pactflow/client.js +11 -4
- package/dist/qmetry/client/api/client-api.js +2 -2
- package/dist/qmetry/client/automation.js +2 -2
- package/dist/qtm4j/http/auth-service.js +2 -2
- package/dist/reflect/client.js +2 -2
- package/dist/swagger/client/api.js +7 -5
- package/dist/swagger/client/functional-testing-api.js +188 -6
- package/dist/swagger/client/functional-testing-tools.js +49 -2
- package/dist/swagger/client/functional-testing-types.js +21 -0
- package/dist/swagger/client/portal-types.js +4 -1
- package/dist/swagger/client.js +19 -0
- package/dist/zephyr/common/auth-service.js +2 -2
- package/dist/zephyr/common/rest-api-schemas.js +2200 -103
- package/package.json +3 -1
|
@@ -132,11 +132,19 @@ zod.object({
|
|
|
132
132
|
errorCode: zod.number(),
|
|
133
133
|
message: zod.string()
|
|
134
134
|
}).strict();
|
|
135
|
+
zod.object({
|
|
136
|
+
errorCode: zod.number(),
|
|
137
|
+
message: zod.string()
|
|
138
|
+
}).strict();
|
|
139
|
+
zod.object({
|
|
140
|
+
errorCode: zod.number(),
|
|
141
|
+
message: zod.string()
|
|
142
|
+
}).strict();
|
|
135
143
|
const createTestCaseBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
136
144
|
const createTestCaseBodyNameMax = 255;
|
|
137
145
|
const createTestCaseBodyNameRegExp = /^(?!\\s*$).+/;
|
|
138
146
|
const createTestCaseBodyEstimatedTimeMin = 0;
|
|
139
|
-
const createTestCaseBodyComponentIdMin =
|
|
147
|
+
const createTestCaseBodyComponentIdMin = 1;
|
|
140
148
|
const createTestCaseBodyPriorityNameMax = 255;
|
|
141
149
|
const createTestCaseBodyStatusNameMax = 255;
|
|
142
150
|
const createTestCaseBodyOwnerIdRegExp = /^[-:a-zA-Z0-9]{1,128}$/;
|
|
@@ -166,6 +174,14 @@ zod.object({
|
|
|
166
174
|
errorCode: zod.number(),
|
|
167
175
|
message: zod.string()
|
|
168
176
|
}).strict();
|
|
177
|
+
zod.object({
|
|
178
|
+
errorCode: zod.number(),
|
|
179
|
+
message: zod.string()
|
|
180
|
+
}).strict();
|
|
181
|
+
zod.object({
|
|
182
|
+
errorCode: zod.number(),
|
|
183
|
+
message: zod.string()
|
|
184
|
+
}).strict();
|
|
169
185
|
const listTestCasesCursorPaginatedQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
170
186
|
const listTestCasesCursorPaginatedQueryLimitDefault = 10;
|
|
171
187
|
const listTestCasesCursorPaginatedQueryLimitMax = 1e3;
|
|
@@ -298,6 +314,14 @@ zod.object({
|
|
|
298
314
|
errorCode: zod.number(),
|
|
299
315
|
message: zod.string()
|
|
300
316
|
}).strict();
|
|
317
|
+
zod.object({
|
|
318
|
+
errorCode: zod.number(),
|
|
319
|
+
message: zod.string()
|
|
320
|
+
}).strict();
|
|
321
|
+
zod.object({
|
|
322
|
+
errorCode: zod.number(),
|
|
323
|
+
message: zod.string()
|
|
324
|
+
}).strict();
|
|
301
325
|
const getTestCasePathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
302
326
|
const GetTestCaseParams = zod.object({
|
|
303
327
|
testCaseKey: zod.string().regex(getTestCasePathTestCaseKeyRegExp).describe(
|
|
@@ -387,6 +411,18 @@ zod.object({
|
|
|
387
411
|
errorCode: zod.number(),
|
|
388
412
|
message: zod.string()
|
|
389
413
|
}).strict();
|
|
414
|
+
zod.object({
|
|
415
|
+
errorCode: zod.number(),
|
|
416
|
+
message: zod.string()
|
|
417
|
+
}).strict();
|
|
418
|
+
zod.object({
|
|
419
|
+
errorCode: zod.number(),
|
|
420
|
+
message: zod.string()
|
|
421
|
+
}).strict();
|
|
422
|
+
zod.object({
|
|
423
|
+
errorCode: zod.number(),
|
|
424
|
+
message: zod.string()
|
|
425
|
+
}).strict();
|
|
390
426
|
const updateTestCasePathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
391
427
|
const UpdateTestCaseParams = zod.object({
|
|
392
428
|
testCaseKey: zod.string().regex(updateTestCasePathTestCaseKeyRegExp).describe(
|
|
@@ -432,6 +468,18 @@ zod.object({
|
|
|
432
468
|
errorCode: zod.number(),
|
|
433
469
|
message: zod.string()
|
|
434
470
|
}).strict();
|
|
471
|
+
zod.object({
|
|
472
|
+
errorCode: zod.number(),
|
|
473
|
+
message: zod.string()
|
|
474
|
+
}).strict();
|
|
475
|
+
zod.object({
|
|
476
|
+
errorCode: zod.number(),
|
|
477
|
+
message: zod.string()
|
|
478
|
+
}).strict();
|
|
479
|
+
zod.object({
|
|
480
|
+
errorCode: zod.number(),
|
|
481
|
+
message: zod.string()
|
|
482
|
+
}).strict();
|
|
435
483
|
const getTestCaseLinksPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
436
484
|
const GetTestCaseLinksParams = zod.object({
|
|
437
485
|
testCaseKey: zod.string().regex(getTestCaseLinksPathTestCaseKeyRegExp).describe(
|
|
@@ -471,6 +519,18 @@ zod.object({
|
|
|
471
519
|
errorCode: zod.number(),
|
|
472
520
|
message: zod.string()
|
|
473
521
|
}).strict();
|
|
522
|
+
zod.object({
|
|
523
|
+
errorCode: zod.number(),
|
|
524
|
+
message: zod.string()
|
|
525
|
+
}).strict();
|
|
526
|
+
zod.object({
|
|
527
|
+
errorCode: zod.number(),
|
|
528
|
+
message: zod.string()
|
|
529
|
+
}).strict();
|
|
530
|
+
zod.object({
|
|
531
|
+
errorCode: zod.number(),
|
|
532
|
+
message: zod.string()
|
|
533
|
+
}).strict();
|
|
474
534
|
const createTestCaseIssueLinkPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
475
535
|
const CreateTestCaseIssueLinkParams = zod.object({
|
|
476
536
|
testCaseKey: zod.string().regex(createTestCaseIssueLinkPathTestCaseKeyRegExp).describe(
|
|
@@ -488,6 +548,18 @@ zod.object({
|
|
|
488
548
|
errorCode: zod.number(),
|
|
489
549
|
message: zod.string()
|
|
490
550
|
}).strict();
|
|
551
|
+
zod.object({
|
|
552
|
+
errorCode: zod.number(),
|
|
553
|
+
message: zod.string()
|
|
554
|
+
}).strict();
|
|
555
|
+
zod.object({
|
|
556
|
+
errorCode: zod.number(),
|
|
557
|
+
message: zod.string()
|
|
558
|
+
}).strict();
|
|
559
|
+
zod.object({
|
|
560
|
+
errorCode: zod.number(),
|
|
561
|
+
message: zod.string()
|
|
562
|
+
}).strict();
|
|
491
563
|
const createTestCaseWebLinkPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
492
564
|
const CreateTestCaseWebLinkParams = zod.object({
|
|
493
565
|
testCaseKey: zod.string().regex(createTestCaseWebLinkPathTestCaseKeyRegExp).describe(
|
|
@@ -506,6 +578,18 @@ zod.object({
|
|
|
506
578
|
errorCode: zod.number(),
|
|
507
579
|
message: zod.string()
|
|
508
580
|
}).strict();
|
|
581
|
+
zod.object({
|
|
582
|
+
errorCode: zod.number(),
|
|
583
|
+
message: zod.string()
|
|
584
|
+
}).strict();
|
|
585
|
+
zod.object({
|
|
586
|
+
errorCode: zod.number(),
|
|
587
|
+
message: zod.string()
|
|
588
|
+
}).strict();
|
|
589
|
+
zod.object({
|
|
590
|
+
errorCode: zod.number(),
|
|
591
|
+
message: zod.string()
|
|
592
|
+
}).strict();
|
|
509
593
|
const listTestCaseVersionsPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
510
594
|
zod.object({
|
|
511
595
|
testCaseKey: zod.string().regex(listTestCaseVersionsPathTestCaseKeyRegExp).describe(
|
|
@@ -551,6 +635,18 @@ zod.object({
|
|
|
551
635
|
errorCode: zod.number(),
|
|
552
636
|
message: zod.string()
|
|
553
637
|
}).strict();
|
|
638
|
+
zod.object({
|
|
639
|
+
errorCode: zod.number(),
|
|
640
|
+
message: zod.string()
|
|
641
|
+
}).strict();
|
|
642
|
+
zod.object({
|
|
643
|
+
errorCode: zod.number(),
|
|
644
|
+
message: zod.string()
|
|
645
|
+
}).strict();
|
|
646
|
+
zod.object({
|
|
647
|
+
errorCode: zod.number(),
|
|
648
|
+
message: zod.string()
|
|
649
|
+
}).strict();
|
|
554
650
|
const getTestCaseVersionPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
555
651
|
zod.object({
|
|
556
652
|
testCaseKey: zod.string().regex(getTestCaseVersionPathTestCaseKeyRegExp).describe(
|
|
@@ -641,6 +737,18 @@ zod.object({
|
|
|
641
737
|
errorCode: zod.number(),
|
|
642
738
|
message: zod.string()
|
|
643
739
|
}).strict();
|
|
740
|
+
zod.object({
|
|
741
|
+
errorCode: zod.number(),
|
|
742
|
+
message: zod.string()
|
|
743
|
+
}).strict();
|
|
744
|
+
zod.object({
|
|
745
|
+
errorCode: zod.number(),
|
|
746
|
+
message: zod.string()
|
|
747
|
+
}).strict();
|
|
748
|
+
zod.object({
|
|
749
|
+
errorCode: zod.number(),
|
|
750
|
+
message: zod.string()
|
|
751
|
+
}).strict();
|
|
644
752
|
const getTestCaseTestScriptPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
645
753
|
const GetTestCaseTestScriptParams = zod.object({
|
|
646
754
|
testCaseKey: zod.string().regex(getTestCaseTestScriptPathTestCaseKeyRegExp).describe(
|
|
@@ -658,6 +766,18 @@ zod.object({
|
|
|
658
766
|
errorCode: zod.number(),
|
|
659
767
|
message: zod.string()
|
|
660
768
|
}).strict();
|
|
769
|
+
zod.object({
|
|
770
|
+
errorCode: zod.number(),
|
|
771
|
+
message: zod.string()
|
|
772
|
+
}).strict();
|
|
773
|
+
zod.object({
|
|
774
|
+
errorCode: zod.number(),
|
|
775
|
+
message: zod.string()
|
|
776
|
+
}).strict();
|
|
777
|
+
zod.object({
|
|
778
|
+
errorCode: zod.number(),
|
|
779
|
+
message: zod.string()
|
|
780
|
+
}).strict();
|
|
661
781
|
const createTestCaseTestScriptPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
662
782
|
const CreateTestCaseTestScriptParams = zod.object({
|
|
663
783
|
testCaseKey: zod.string().regex(createTestCaseTestScriptPathTestCaseKeyRegExp).describe(
|
|
@@ -678,6 +798,18 @@ zod.object({
|
|
|
678
798
|
errorCode: zod.number(),
|
|
679
799
|
message: zod.string()
|
|
680
800
|
}).strict();
|
|
801
|
+
zod.object({
|
|
802
|
+
errorCode: zod.number(),
|
|
803
|
+
message: zod.string()
|
|
804
|
+
}).strict();
|
|
805
|
+
zod.object({
|
|
806
|
+
errorCode: zod.number(),
|
|
807
|
+
message: zod.string()
|
|
808
|
+
}).strict();
|
|
809
|
+
zod.object({
|
|
810
|
+
errorCode: zod.number(),
|
|
811
|
+
message: zod.string()
|
|
812
|
+
}).strict();
|
|
681
813
|
const getTestCaseTestStepsPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
682
814
|
const GetTestCaseTestStepsParams = zod.object({
|
|
683
815
|
testCaseKey: zod.string().regex(getTestCaseTestStepsPathTestCaseKeyRegExp).describe(
|
|
@@ -715,6 +847,7 @@ const GetTestCaseTestSteps200Response = zod.object({
|
|
|
715
847
|
isLast: zod.boolean().optional().describe("Indicates if this is the last page of results."),
|
|
716
848
|
values: zod.array(
|
|
717
849
|
zod.object({
|
|
850
|
+
id: zod.number().min(1).nullish().describe("The ID of the test step."),
|
|
718
851
|
inline: zod.object({
|
|
719
852
|
description: zod.string().nullish().describe("The instruction to be followed"),
|
|
720
853
|
testData: zod.string().nullish().describe(
|
|
@@ -756,6 +889,18 @@ zod.object({
|
|
|
756
889
|
errorCode: zod.number(),
|
|
757
890
|
message: zod.string()
|
|
758
891
|
}).strict();
|
|
892
|
+
zod.object({
|
|
893
|
+
errorCode: zod.number(),
|
|
894
|
+
message: zod.string()
|
|
895
|
+
}).strict();
|
|
896
|
+
zod.object({
|
|
897
|
+
errorCode: zod.number(),
|
|
898
|
+
message: zod.string()
|
|
899
|
+
}).strict();
|
|
900
|
+
zod.object({
|
|
901
|
+
errorCode: zod.number(),
|
|
902
|
+
message: zod.string()
|
|
903
|
+
}).strict();
|
|
759
904
|
const createTestCaseTestStepsPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
760
905
|
const CreateTestCaseTestStepsParams = zod.object({
|
|
761
906
|
testCaseKey: zod.string().regex(createTestCaseTestStepsPathTestCaseKeyRegExp).describe(
|
|
@@ -818,84 +963,284 @@ zod.object({
|
|
|
818
963
|
errorCode: zod.number(),
|
|
819
964
|
message: zod.string()
|
|
820
965
|
}).strict();
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
966
|
+
zod.object({
|
|
967
|
+
errorCode: zod.number(),
|
|
968
|
+
message: zod.string()
|
|
969
|
+
}).strict();
|
|
970
|
+
zod.object({
|
|
971
|
+
errorCode: zod.number(),
|
|
972
|
+
message: zod.string()
|
|
973
|
+
}).strict();
|
|
974
|
+
zod.object({
|
|
975
|
+
errorCode: zod.number(),
|
|
976
|
+
message: zod.string()
|
|
977
|
+
}).strict();
|
|
978
|
+
const getTestCaseAttachmentPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
979
|
+
zod.object({
|
|
980
|
+
testCaseKey: zod.string().regex(getTestCaseAttachmentPathTestCaseKeyRegExp).describe(
|
|
981
|
+
"The key of the test case. Test case keys are of the format [A-Z]+-T[0-9]+"
|
|
831
982
|
),
|
|
832
|
-
|
|
833
|
-
|
|
983
|
+
attachmentId: zod.number().min(1).describe("The numeric ID of the attachment.")
|
|
984
|
+
}).strict();
|
|
985
|
+
zod.object({
|
|
986
|
+
errorCode: zod.number(),
|
|
987
|
+
message: zod.string()
|
|
988
|
+
}).strict();
|
|
989
|
+
zod.object({
|
|
990
|
+
errorCode: zod.number(),
|
|
991
|
+
message: zod.string()
|
|
992
|
+
}).strict();
|
|
993
|
+
zod.object({
|
|
994
|
+
errorCode: zod.number(),
|
|
995
|
+
message: zod.string()
|
|
996
|
+
}).strict();
|
|
997
|
+
zod.object({
|
|
998
|
+
errorCode: zod.number(),
|
|
999
|
+
message: zod.string()
|
|
1000
|
+
}).strict();
|
|
1001
|
+
zod.object({
|
|
1002
|
+
errorCode: zod.number(),
|
|
1003
|
+
message: zod.string()
|
|
1004
|
+
}).strict();
|
|
1005
|
+
const uploadTestCaseAttachmentPathTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
1006
|
+
const uploadTestCaseAttachmentPathFileNameMax = 255;
|
|
1007
|
+
zod.object({
|
|
1008
|
+
testCaseKey: zod.string().regex(uploadTestCaseAttachmentPathTestCaseKeyRegExp).describe(
|
|
1009
|
+
"The key of the test case. Test case keys are of the format [A-Z]+-T[0-9]+"
|
|
834
1010
|
),
|
|
835
|
-
|
|
836
|
-
"
|
|
1011
|
+
fileName: zod.string().min(1).max(uploadTestCaseAttachmentPathFileNameMax).describe(
|
|
1012
|
+
"The name of the file being uploaded, including its extension (for example, `screenshot.png`).\nThis is used as the attachment's display name. URL-encode any special characters and keep\nthe name to 255 characters or fewer.\n"
|
|
837
1013
|
)
|
|
838
|
-
});
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
)
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
),
|
|
857
|
-
|
|
858
|
-
|
|
859
|
-
|
|
860
|
-
|
|
861
|
-
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
868
|
-
|
|
869
|
-
|
|
870
|
-
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
1014
|
+
}).strict();
|
|
1015
|
+
zod.object({
|
|
1016
|
+
errorCode: zod.number(),
|
|
1017
|
+
message: zod.string()
|
|
1018
|
+
}).strict();
|
|
1019
|
+
zod.object({
|
|
1020
|
+
errorCode: zod.number(),
|
|
1021
|
+
message: zod.string()
|
|
1022
|
+
}).strict();
|
|
1023
|
+
zod.object({
|
|
1024
|
+
errorCode: zod.number(),
|
|
1025
|
+
message: zod.string()
|
|
1026
|
+
}).strict();
|
|
1027
|
+
zod.object({
|
|
1028
|
+
errorCode: zod.number(),
|
|
1029
|
+
message: zod.string()
|
|
1030
|
+
}).strict();
|
|
1031
|
+
zod.object({
|
|
1032
|
+
errorCode: zod.number(),
|
|
1033
|
+
message: zod.string()
|
|
1034
|
+
}).strict();
|
|
1035
|
+
zod.object({
|
|
1036
|
+
errorCode: zod.number(),
|
|
1037
|
+
message: zod.string()
|
|
1038
|
+
}).strict();
|
|
1039
|
+
zod.object({
|
|
1040
|
+
errorCode: zod.number(),
|
|
1041
|
+
message: zod.string()
|
|
1042
|
+
}).strict();
|
|
1043
|
+
const createTestCaseTestStepAttachmentPathTestCaseIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-T[0-9]+)/;
|
|
1044
|
+
const createTestCaseTestStepAttachmentPathFileNameMax = 255;
|
|
1045
|
+
zod.object({
|
|
1046
|
+
testCaseIdOrKey: zod.string().regex(createTestCaseTestStepAttachmentPathTestCaseIdOrKeyRegExp).describe("The ID or key of the test case."),
|
|
1047
|
+
testCaseStepId: zod.number().min(1).describe("The ID of the step within the test case."),
|
|
1048
|
+
fileName: zod.string().min(1).max(createTestCaseTestStepAttachmentPathFileNameMax).describe(
|
|
1049
|
+
"The name of the file being uploaded, including its extension (for example, `screenshot.png`).\nThis is used as the attachment's display name. URL-encode any special characters and keep\nthe name to 255 characters or fewer.\n"
|
|
1050
|
+
)
|
|
1051
|
+
}).strict();
|
|
1052
|
+
zod.object({
|
|
1053
|
+
errorCode: zod.number(),
|
|
1054
|
+
message: zod.string()
|
|
1055
|
+
}).strict();
|
|
1056
|
+
zod.object({
|
|
1057
|
+
errorCode: zod.number(),
|
|
1058
|
+
message: zod.string()
|
|
1059
|
+
}).strict();
|
|
1060
|
+
zod.object({
|
|
1061
|
+
errorCode: zod.number(),
|
|
1062
|
+
message: zod.string()
|
|
1063
|
+
}).strict();
|
|
1064
|
+
zod.object({
|
|
1065
|
+
errorCode: zod.number(),
|
|
1066
|
+
message: zod.string()
|
|
1067
|
+
}).strict();
|
|
1068
|
+
zod.object({
|
|
1069
|
+
errorCode: zod.number(),
|
|
1070
|
+
message: zod.string()
|
|
1071
|
+
}).strict();
|
|
1072
|
+
zod.object({
|
|
1073
|
+
errorCode: zod.number(),
|
|
1074
|
+
message: zod.string()
|
|
1075
|
+
}).strict();
|
|
1076
|
+
zod.object({
|
|
1077
|
+
errorCode: zod.number(),
|
|
1078
|
+
message: zod.string()
|
|
1079
|
+
}).strict();
|
|
1080
|
+
const getTestCaseStepAttachmentPathTestCaseIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-T[0-9]+)/;
|
|
1081
|
+
zod.object({
|
|
1082
|
+
testCaseIdOrKey: zod.string().regex(getTestCaseStepAttachmentPathTestCaseIdOrKeyRegExp).describe("The ID or key of the test case."),
|
|
1083
|
+
testCaseStepId: zod.number().min(1).describe("The ID of the step within the test case."),
|
|
1084
|
+
attachmentId: zod.number().min(1).describe("The numeric ID of the attachment.")
|
|
1085
|
+
}).strict();
|
|
1086
|
+
zod.object({
|
|
1087
|
+
errorCode: zod.number(),
|
|
1088
|
+
message: zod.string()
|
|
1089
|
+
}).strict();
|
|
1090
|
+
zod.object({
|
|
1091
|
+
errorCode: zod.number(),
|
|
1092
|
+
message: zod.string()
|
|
1093
|
+
}).strict();
|
|
1094
|
+
zod.object({
|
|
1095
|
+
errorCode: zod.number(),
|
|
1096
|
+
message: zod.string()
|
|
1097
|
+
}).strict();
|
|
1098
|
+
zod.object({
|
|
1099
|
+
errorCode: zod.number(),
|
|
1100
|
+
message: zod.string()
|
|
1101
|
+
}).strict();
|
|
1102
|
+
zod.object({
|
|
1103
|
+
errorCode: zod.number(),
|
|
1104
|
+
message: zod.string()
|
|
1105
|
+
}).strict();
|
|
1106
|
+
const getTestCaseTestStepAttachmentsReferencePathTestCaseIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-T[0-9]+)/;
|
|
1107
|
+
const getTestCaseTestStepAttachmentsReferencePathTestStepIdRegExp = /([0-9]+)/;
|
|
1108
|
+
zod.object({
|
|
1109
|
+
testCaseIdOrKey: zod.string().regex(getTestCaseTestStepAttachmentsReferencePathTestCaseIdOrKeyRegExp).describe("The ID or key of the test case."),
|
|
1110
|
+
testStepId: zod.string().regex(getTestCaseTestStepAttachmentsReferencePathTestStepIdRegExp).describe(
|
|
1111
|
+
"The ID of the test case step. Test step IDs are numeric, of the format [0-9]+"
|
|
1112
|
+
)
|
|
1113
|
+
}).strict();
|
|
1114
|
+
zod.object({
|
|
1115
|
+
attachments: zod.array(
|
|
1116
|
+
zod.object({
|
|
1117
|
+
id: zod.number().optional().describe("Database ID of the attachment."),
|
|
1118
|
+
name: zod.string().optional().describe("File name of the attachment.")
|
|
1119
|
+
}).strict()
|
|
1120
|
+
).optional()
|
|
1121
|
+
}).strict();
|
|
1122
|
+
zod.object({
|
|
1123
|
+
errorCode: zod.number(),
|
|
1124
|
+
message: zod.string()
|
|
1125
|
+
}).strict();
|
|
1126
|
+
zod.object({
|
|
1127
|
+
errorCode: zod.number(),
|
|
1128
|
+
message: zod.string()
|
|
1129
|
+
}).strict();
|
|
1130
|
+
zod.object({
|
|
1131
|
+
errorCode: zod.number(),
|
|
1132
|
+
message: zod.string()
|
|
1133
|
+
}).strict();
|
|
1134
|
+
zod.object({
|
|
1135
|
+
errorCode: zod.number(),
|
|
1136
|
+
message: zod.string()
|
|
1137
|
+
}).strict();
|
|
1138
|
+
const getTestCaseAttachmentsReferencePathTestCaseIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-T[0-9]+)/;
|
|
1139
|
+
zod.object({
|
|
1140
|
+
testCaseIdOrKey: zod.string().regex(getTestCaseAttachmentsReferencePathTestCaseIdOrKeyRegExp).describe("The ID or key of the test case.")
|
|
1141
|
+
}).strict();
|
|
1142
|
+
zod.object({
|
|
1143
|
+
attachments: zod.array(
|
|
1144
|
+
zod.object({
|
|
1145
|
+
id: zod.number().optional().describe("Database ID of the attachment."),
|
|
1146
|
+
name: zod.string().optional().describe("File name of the attachment.")
|
|
1147
|
+
}).strict()
|
|
1148
|
+
).optional()
|
|
1149
|
+
}).strict();
|
|
1150
|
+
zod.object({
|
|
1151
|
+
errorCode: zod.number(),
|
|
1152
|
+
message: zod.string()
|
|
1153
|
+
}).strict();
|
|
1154
|
+
zod.object({
|
|
1155
|
+
errorCode: zod.number(),
|
|
1156
|
+
message: zod.string()
|
|
1157
|
+
}).strict();
|
|
1158
|
+
zod.object({
|
|
1159
|
+
errorCode: zod.number(),
|
|
1160
|
+
message: zod.string()
|
|
1161
|
+
}).strict();
|
|
1162
|
+
zod.object({
|
|
1163
|
+
errorCode: zod.number(),
|
|
1164
|
+
message: zod.string()
|
|
1165
|
+
}).strict();
|
|
1166
|
+
const listTestCyclesQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
1167
|
+
const listTestCyclesQueryMaxResultsDefault = 10;
|
|
1168
|
+
const listTestCyclesQueryStartAtDefault = 0;
|
|
1169
|
+
const listTestCyclesQueryStartAtMin = 0;
|
|
1170
|
+
const listTestCyclesQueryStartAtMax = 1e6;
|
|
1171
|
+
const ListTestCyclesQueryParams = zod.object({
|
|
1172
|
+
projectKey: zod.string().regex(listTestCyclesQueryProjectKeyRegExp).optional().describe("Jira project key filter"),
|
|
1173
|
+
folderId: zod.number().min(1).optional().describe("Folder ID filter"),
|
|
1174
|
+
jiraProjectVersionId: zod.number().min(1).optional().describe(
|
|
1175
|
+
"Jira Project Version ID. Relates to 'Version' or 'Releases' in Jira projects."
|
|
1176
|
+
),
|
|
1177
|
+
maxResults: zod.number().min(1).default(listTestCyclesQueryMaxResultsDefault).describe(
|
|
1178
|
+
"Specifies the maximum number of results to return in a single call. The default value is 10, and the maximum value that can be requested is 1000.\n\nNote that the server may enforce a lower limit than requested, depending on resource availability or other internal constraints. If this happens, the result set may be truncated. Always check the maxResults value in the response to confirm how many results were actually returned.\n"
|
|
1179
|
+
),
|
|
1180
|
+
startAt: zod.number().min(listTestCyclesQueryStartAtMin).max(listTestCyclesQueryStartAtMax).default(listTestCyclesQueryStartAtDefault).describe(
|
|
1181
|
+
"Zero-indexed starting position. Should be a multiple of maxResults."
|
|
1182
|
+
)
|
|
1183
|
+
});
|
|
1184
|
+
const listTestCycles200ResponseOneStartAtMin = 0;
|
|
1185
|
+
const listTestCycles200ResponseOneTotalMin = 0;
|
|
1186
|
+
const listTestCycles200ResponseTwoValuesItemKeyRegExp = /([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
1187
|
+
const listTestCycles200ResponseTwoValuesItemNameRegExp = /^(?!\s*$).+/;
|
|
1188
|
+
const listTestCycles200ResponseTwoValuesItemOwnerAccountIdRegExp = /^[-:a-zA-Z0-9]{1,128}$/;
|
|
1189
|
+
const ListTestCycles200Response = zod.object({
|
|
1190
|
+
next: zod.string().url().nullish().describe(
|
|
1191
|
+
"URL to the next page of results, or null if there are no more results."
|
|
1192
|
+
),
|
|
1193
|
+
startAt: zod.number().min(listTestCycles200ResponseOneStartAtMin).describe(
|
|
1194
|
+
"Indicates the index of the first item returned in the page of results."
|
|
1195
|
+
),
|
|
1196
|
+
maxResults: zod.number().min(1).describe(
|
|
1197
|
+
"Indicates the maximum number of results in this response. Note that the server may enforce a lower limit than requested, depending on resource availability or other internal constraints."
|
|
1198
|
+
),
|
|
1199
|
+
total: zod.number().min(listTestCycles200ResponseOneTotalMin).optional().describe(
|
|
1200
|
+
"Indicates the total number of items available across all pages."
|
|
1201
|
+
),
|
|
1202
|
+
isLast: zod.boolean().optional().describe("Indicates if this is the last page of results."),
|
|
1203
|
+
values: zod.array(
|
|
1204
|
+
zod.object({
|
|
1205
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1206
|
+
key: zod.string().regex(listTestCycles200ResponseTwoValuesItemKeyRegExp).describe("Unique key of the test cycle"),
|
|
1207
|
+
name: zod.string().regex(listTestCycles200ResponseTwoValuesItemNameRegExp).describe("Name of the Test Cycle"),
|
|
1208
|
+
project: zod.object({
|
|
1209
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1210
|
+
self: zod.string().url().optional().describe(
|
|
1211
|
+
"The REST API endpoint to get more resource details."
|
|
1212
|
+
)
|
|
1213
|
+
}).strict().describe("ID and link relative to Zephyr project."),
|
|
1214
|
+
jiraProjectVersion: zod.object({
|
|
1215
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1216
|
+
self: zod.string().url().optional().describe(
|
|
1217
|
+
"The REST API endpoint to get more resource details."
|
|
1218
|
+
)
|
|
1219
|
+
}).strict().nullish().describe(
|
|
1220
|
+
"ID and Link to fetch information about Jira Project version. Relates to 'Version' or 'Releases' in Jira projects."
|
|
1221
|
+
),
|
|
1222
|
+
status: zod.object({
|
|
1223
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1224
|
+
self: zod.string().url().optional().describe(
|
|
1225
|
+
"The REST API endpoint to get more resource details."
|
|
1226
|
+
)
|
|
1227
|
+
}).strict().describe("ID and link to the status resource."),
|
|
1228
|
+
folder: zod.object({
|
|
1229
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1230
|
+
self: zod.string().url().optional().describe(
|
|
1231
|
+
"The REST API endpoint to get more resource details."
|
|
1232
|
+
)
|
|
1233
|
+
}).strict().nullish().describe("ID and link to the folder resource."),
|
|
1234
|
+
description: zod.string().nullish().describe("Description outlining the scope."),
|
|
1235
|
+
plannedStartDate: zod.string().datetime({}).nullish().describe(
|
|
1236
|
+
"Planned start date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1237
|
+
),
|
|
1238
|
+
plannedEndDate: zod.string().datetime({}).nullish().describe(
|
|
1239
|
+
"The planned end date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1240
|
+
),
|
|
1241
|
+
owner: zod.object({
|
|
1242
|
+
accountId: zod.string().regex(
|
|
1243
|
+
listTestCycles200ResponseTwoValuesItemOwnerAccountIdRegExp
|
|
899
1244
|
).nullable().describe("Atlassian Account ID of the Jira user."),
|
|
900
1245
|
self: zod.string().url().optional().describe(
|
|
901
1246
|
"The Jira REST API endpoint to get the full representation of the Jira user."
|
|
@@ -953,6 +1298,67 @@ const ListTestCycles200Response = zod.object({
|
|
|
953
1298
|
}).strict().describe("Details of a test cycle")
|
|
954
1299
|
).optional()
|
|
955
1300
|
}).strict();
|
|
1301
|
+
zod.union([
|
|
1302
|
+
zod.object({
|
|
1303
|
+
errorCode: zod.number(),
|
|
1304
|
+
message: zod.string()
|
|
1305
|
+
}).strict().describe(
|
|
1306
|
+
"A query parameter failed validation at the API layer (projectKey pattern, or the numeric bounds maxResults >= 1, startAt 0..1000000, folderId >= 1, jiraProjectVersionId >= 1)."
|
|
1307
|
+
),
|
|
1308
|
+
zod.object({
|
|
1309
|
+
errorCode: zod.number(),
|
|
1310
|
+
message: zod.string()
|
|
1311
|
+
}).strict().describe("A numeric query parameter was sent with a non-numeric value.")
|
|
1312
|
+
]);
|
|
1313
|
+
zod.union([
|
|
1314
|
+
zod.object({
|
|
1315
|
+
error: zod.string()
|
|
1316
|
+
}).strict().describe("The Authorization header is missing."),
|
|
1317
|
+
zod.object({
|
|
1318
|
+
error: zod.string()
|
|
1319
|
+
}).strict().describe(
|
|
1320
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
1321
|
+
),
|
|
1322
|
+
zod.object({
|
|
1323
|
+
error: zod.string()
|
|
1324
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
1325
|
+
zod.object({
|
|
1326
|
+
error: zod.string()
|
|
1327
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
1328
|
+
zod.object({
|
|
1329
|
+
error: zod.string()
|
|
1330
|
+
}).strict().describe(
|
|
1331
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
1332
|
+
)
|
|
1333
|
+
]);
|
|
1334
|
+
zod.union([
|
|
1335
|
+
zod.object({
|
|
1336
|
+
errorCode: zod.number(),
|
|
1337
|
+
message: zod.string()
|
|
1338
|
+
}).strict().describe(
|
|
1339
|
+
"The projectKey filter refers to a project that does not exist or is deactivated."
|
|
1340
|
+
),
|
|
1341
|
+
zod.object({
|
|
1342
|
+
errorCode: zod.number(),
|
|
1343
|
+
message: zod.string()
|
|
1344
|
+
}).strict().describe("The folderId filter refers to a folder that does not exist."),
|
|
1345
|
+
zod.object({
|
|
1346
|
+
errorCode: zod.number(),
|
|
1347
|
+
message: zod.string()
|
|
1348
|
+
}).strict().describe(
|
|
1349
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
1350
|
+
),
|
|
1351
|
+
zod.object({
|
|
1352
|
+
errorCode: zod.number(),
|
|
1353
|
+
message: zod.string()
|
|
1354
|
+
}).strict().describe(
|
|
1355
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
1356
|
+
)
|
|
1357
|
+
]);
|
|
1358
|
+
zod.object({
|
|
1359
|
+
errorCode: zod.number(),
|
|
1360
|
+
message: zod.string()
|
|
1361
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
956
1362
|
zod.object({
|
|
957
1363
|
errorCode: zod.number(),
|
|
958
1364
|
message: zod.string()
|
|
@@ -987,17 +1393,357 @@ const CreateTestCycle201Response = zod.object({
|
|
|
987
1393
|
self: zod.string().optional(),
|
|
988
1394
|
key: zod.string().optional()
|
|
989
1395
|
}).strict();
|
|
990
|
-
zod.
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1396
|
+
zod.union([
|
|
1397
|
+
zod.object({
|
|
1398
|
+
errorCode: zod.number(),
|
|
1399
|
+
message: zod.string()
|
|
1400
|
+
}).strict().describe(
|
|
1401
|
+
"A request body field failed validation at the API layer (required field missing, pattern mismatch, size, or numeric bound)."
|
|
1402
|
+
),
|
|
1403
|
+
zod.object({
|
|
1404
|
+
errorCode: zod.number(),
|
|
1405
|
+
message: zod.string()
|
|
1406
|
+
}).strict().describe(
|
|
1407
|
+
"A request body field has the wrong type or format (for example a non-ISO-8601 date)."
|
|
1408
|
+
),
|
|
1409
|
+
zod.object({
|
|
1410
|
+
errorCode: zod.number(),
|
|
1411
|
+
message: zod.string()
|
|
1412
|
+
}).strict().describe("The request body is not valid JSON."),
|
|
1413
|
+
zod.object({
|
|
1414
|
+
errorCode: zod.number(),
|
|
1415
|
+
message: zod.string()
|
|
1416
|
+
}).strict().describe(
|
|
1417
|
+
"The folderId in the body refers to a folder that does not exist."
|
|
1418
|
+
),
|
|
1419
|
+
zod.object({
|
|
1420
|
+
errorCode: zod.number(),
|
|
1421
|
+
message: zod.string()
|
|
1422
|
+
}).strict().describe(
|
|
1423
|
+
"The folderId refers to a folder that is not a TEST_CYCLE folder."
|
|
1424
|
+
),
|
|
1425
|
+
zod.object({
|
|
1426
|
+
errorCode: zod.number(),
|
|
1427
|
+
message: zod.string()
|
|
1428
|
+
}).strict().describe(
|
|
1429
|
+
"A custom field name in the body does not exist for the project."
|
|
1430
|
+
),
|
|
1431
|
+
zod.object({
|
|
1432
|
+
errorCode: zod.number(),
|
|
1433
|
+
message: zod.string()
|
|
1434
|
+
}).strict().describe(
|
|
1435
|
+
'A custom field value has the wrong type for the field definition. The message names the field and the expected type, e.g. "requires a number value", "requires a string value", "requires a boolean value", "requires a string which is in the format yyyy-MM-dd", or "requires a list".\n'
|
|
1436
|
+
),
|
|
1437
|
+
zod.object({
|
|
1438
|
+
errorCode: zod.number(),
|
|
1439
|
+
message: zod.string()
|
|
1440
|
+
}).strict().describe(
|
|
1441
|
+
"A choice custom field value references an option name that does not exist."
|
|
1442
|
+
),
|
|
1443
|
+
zod.object({
|
|
1444
|
+
errorCode: zod.number(),
|
|
1445
|
+
message: zod.string()
|
|
1446
|
+
}).strict().describe(
|
|
1447
|
+
"The project has required custom fields but the request omitted them."
|
|
1448
|
+
),
|
|
1449
|
+
zod.object({
|
|
1450
|
+
errorCode: zod.number(),
|
|
1451
|
+
message: zod.string()
|
|
1452
|
+
}).strict().describe(
|
|
1453
|
+
"Custom fields were provided but not all required ones are present."
|
|
1454
|
+
),
|
|
1455
|
+
zod.object({
|
|
1456
|
+
errorCode: zod.number(),
|
|
1457
|
+
message: zod.string()
|
|
1458
|
+
}).strict().describe(
|
|
1459
|
+
"A required custom field was provided with a null or empty value."
|
|
1460
|
+
),
|
|
1461
|
+
zod.object({
|
|
1462
|
+
errorCode: zod.number(),
|
|
1463
|
+
message: zod.string()
|
|
1464
|
+
}).strict().describe(
|
|
1465
|
+
"A required multi-choice custom field was set to an empty collection."
|
|
1466
|
+
)
|
|
1467
|
+
]);
|
|
1468
|
+
zod.union([
|
|
1469
|
+
zod.object({
|
|
1470
|
+
error: zod.string()
|
|
1471
|
+
}).strict().describe("The Authorization header is missing."),
|
|
1472
|
+
zod.object({
|
|
1473
|
+
error: zod.string()
|
|
1474
|
+
}).strict().describe(
|
|
1475
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
1476
|
+
),
|
|
1477
|
+
zod.object({
|
|
1478
|
+
error: zod.string()
|
|
1479
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
1480
|
+
zod.object({
|
|
1481
|
+
error: zod.string()
|
|
1482
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
1483
|
+
zod.object({
|
|
1484
|
+
error: zod.string()
|
|
1485
|
+
}).strict().describe(
|
|
1486
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
1487
|
+
)
|
|
1488
|
+
]);
|
|
1489
|
+
zod.union([
|
|
1490
|
+
zod.object({
|
|
1491
|
+
errorCode: zod.number(),
|
|
1492
|
+
message: zod.string()
|
|
1493
|
+
}).strict().describe(
|
|
1494
|
+
"The caller lacks a required Zephyr permission (when the project's permission system is enabled)."
|
|
1495
|
+
),
|
|
1496
|
+
zod.object({
|
|
1497
|
+
errorCode: zod.number(),
|
|
1498
|
+
message: zod.string()
|
|
1499
|
+
}).strict().describe("Referenced custom fields do not belong to the current client.")
|
|
1500
|
+
]);
|
|
1501
|
+
zod.union([
|
|
1502
|
+
zod.object({
|
|
1503
|
+
errorCode: zod.number(),
|
|
1504
|
+
message: zod.string()
|
|
1505
|
+
}).strict().describe(
|
|
1506
|
+
"The projectKey filter refers to a project that does not exist or is deactivated."
|
|
1507
|
+
),
|
|
1508
|
+
zod.object({
|
|
1509
|
+
errorCode: zod.number(),
|
|
1510
|
+
message: zod.string()
|
|
1511
|
+
}).strict().describe("The statusName does not exist for the project."),
|
|
1512
|
+
zod.object({
|
|
1513
|
+
errorCode: zod.number(),
|
|
1514
|
+
message: zod.string()
|
|
1515
|
+
}).strict().describe(
|
|
1516
|
+
"No statusName was supplied and the project has no default status of the relevant group."
|
|
1517
|
+
),
|
|
1518
|
+
zod.object({
|
|
1519
|
+
errorCode: zod.number(),
|
|
1520
|
+
message: zod.string()
|
|
1521
|
+
}).strict().describe(
|
|
1522
|
+
"A referenced Jira entity (e.g. jiraProjectVersion) does not exist or is not accessible."
|
|
1523
|
+
),
|
|
1524
|
+
zod.object({
|
|
1525
|
+
errorCode: zod.number(),
|
|
1526
|
+
message: zod.string()
|
|
1527
|
+
}).strict().describe(
|
|
1528
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
1529
|
+
),
|
|
1530
|
+
zod.object({
|
|
1531
|
+
errorCode: zod.number(),
|
|
1532
|
+
message: zod.string()
|
|
1533
|
+
}).strict().describe(
|
|
1534
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
1535
|
+
)
|
|
1536
|
+
]);
|
|
1537
|
+
zod.object({
|
|
1538
|
+
errorCode: zod.number(),
|
|
1539
|
+
message: zod.string()
|
|
1540
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
1541
|
+
zod.object({
|
|
1542
|
+
errorCode: zod.number(),
|
|
1543
|
+
message: zod.string()
|
|
1544
|
+
}).strict();
|
|
1545
|
+
const listTestCyclesCursorPaginatedQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
1546
|
+
const listTestCyclesCursorPaginatedQueryLimitDefault = 10;
|
|
1547
|
+
const listTestCyclesCursorPaginatedQueryLimitMax = 1e3;
|
|
1548
|
+
const listTestCyclesCursorPaginatedQueryStartAtIdDefault = 0;
|
|
1549
|
+
const listTestCyclesCursorPaginatedQueryStartAtIdMin = 0;
|
|
1550
|
+
zod.object({
|
|
1551
|
+
projectKey: zod.string().regex(listTestCyclesCursorPaginatedQueryProjectKeyRegExp).optional().describe("Jira project key filter"),
|
|
1552
|
+
folderId: zod.number().min(1).optional().describe("Folder ID filter"),
|
|
1553
|
+
jiraProjectVersionId: zod.number().min(1).optional().describe(
|
|
1554
|
+
"Jira Project Version ID. Relates to 'Version' or 'Releases' in Jira projects."
|
|
1555
|
+
),
|
|
1556
|
+
limit: zod.number().min(1).max(listTestCyclesCursorPaginatedQueryLimitMax).default(listTestCyclesCursorPaginatedQueryLimitDefault).describe(
|
|
1557
|
+
"Specifies the maximum number of results to return in a single call. The default value is 10, and the maximum value that can be requested is 1000.\n\nNote that the server may enforce a lower limit than requested, depending on resource availability or other internal constraints. If this happens, the result set may be truncated. Always check the limit value in the response to confirm how many results were actually returned.\n"
|
|
1558
|
+
),
|
|
1559
|
+
startAtId: zod.number().min(listTestCyclesCursorPaginatedQueryStartAtIdMin).default(listTestCyclesCursorPaginatedQueryStartAtIdDefault).describe("Zero-indexed starting position for ID-based pagination."),
|
|
1560
|
+
updatedAfter: zod.string().datetime({}).optional().describe(
|
|
1561
|
+
"Filter only entities updated after the given time. Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
|
|
1562
|
+
)
|
|
1563
|
+
});
|
|
1564
|
+
const listTestCyclesCursorPaginated200ResponseOneNextStartAtIdMin = 0;
|
|
1565
|
+
const listTestCyclesCursorPaginated200ResponseOneLimitMin = 0;
|
|
1566
|
+
const listTestCyclesCursorPaginated200ResponseTwoValuesItemKeyRegExp = /([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
1567
|
+
const listTestCyclesCursorPaginated200ResponseTwoValuesItemNameRegExp = /^(?!\s*$).+/;
|
|
1568
|
+
const listTestCyclesCursorPaginated200ResponseTwoValuesItemOwnerAccountIdRegExp = /^[-:a-zA-Z0-9]{1,128}$/;
|
|
1569
|
+
zod.object({
|
|
1570
|
+
next: zod.string().url().nullish(),
|
|
1571
|
+
nextStartAtId: zod.number().min(listTestCyclesCursorPaginated200ResponseOneNextStartAtIdMin).nullable(),
|
|
1572
|
+
limit: zod.number().min(listTestCyclesCursorPaginated200ResponseOneLimitMin),
|
|
1573
|
+
values: zod.array(
|
|
1574
|
+
zod.object({
|
|
1575
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1576
|
+
key: zod.string().regex(
|
|
1577
|
+
listTestCyclesCursorPaginated200ResponseTwoValuesItemKeyRegExp
|
|
1578
|
+
).describe("Unique key of the test cycle"),
|
|
1579
|
+
name: zod.string().regex(
|
|
1580
|
+
listTestCyclesCursorPaginated200ResponseTwoValuesItemNameRegExp
|
|
1581
|
+
).describe("Name of the Test Cycle"),
|
|
1582
|
+
project: zod.object({
|
|
1583
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1584
|
+
self: zod.string().url().optional().describe(
|
|
1585
|
+
"The REST API endpoint to get more resource details."
|
|
1586
|
+
)
|
|
1587
|
+
}).strict().describe("ID and link relative to Zephyr project."),
|
|
1588
|
+
jiraProjectVersion: zod.object({
|
|
1589
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1590
|
+
self: zod.string().url().optional().describe(
|
|
1591
|
+
"The REST API endpoint to get more resource details."
|
|
1592
|
+
)
|
|
1593
|
+
}).strict().nullish().describe(
|
|
1594
|
+
"ID and Link to fetch information about Jira Project version. Relates to 'Version' or 'Releases' in Jira projects."
|
|
1595
|
+
),
|
|
1596
|
+
status: zod.object({
|
|
1597
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1598
|
+
self: zod.string().url().optional().describe(
|
|
1599
|
+
"The REST API endpoint to get more resource details."
|
|
1600
|
+
)
|
|
1601
|
+
}).strict().describe("ID and link to the status resource."),
|
|
1602
|
+
folder: zod.object({
|
|
1603
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1604
|
+
self: zod.string().url().optional().describe(
|
|
1605
|
+
"The REST API endpoint to get more resource details."
|
|
1606
|
+
)
|
|
1607
|
+
}).strict().nullish().describe("ID and link to the folder resource."),
|
|
1608
|
+
description: zod.string().nullish().describe("Description outlining the scope."),
|
|
1609
|
+
plannedStartDate: zod.string().datetime({}).nullish().describe(
|
|
1610
|
+
"Planned start date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1611
|
+
),
|
|
1612
|
+
plannedEndDate: zod.string().datetime({}).nullish().describe(
|
|
1613
|
+
"The planned end date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1614
|
+
),
|
|
1615
|
+
owner: zod.object({
|
|
1616
|
+
accountId: zod.string().regex(
|
|
1617
|
+
listTestCyclesCursorPaginated200ResponseTwoValuesItemOwnerAccountIdRegExp
|
|
1618
|
+
).nullable().describe("Atlassian Account ID of the Jira user."),
|
|
1619
|
+
self: zod.string().url().optional().describe(
|
|
1620
|
+
"The Jira REST API endpoint to get the full representation of the Jira user."
|
|
1621
|
+
)
|
|
1622
|
+
}).strict().nullish(),
|
|
1623
|
+
customFields: zod.record(zod.string(), zod.unknown()).optional().describe(
|
|
1624
|
+
"Multi-line text fields support HTML and should denote new lines with the \\<br\\> tag.\nDates should be in the format 'yyyy-MM-dd'.\nUsers should have values of Jira User Account IDs.\n"
|
|
1625
|
+
),
|
|
1626
|
+
links: zod.object({
|
|
1627
|
+
self: zod.string().url().optional().describe(
|
|
1628
|
+
"The REST API endpoint to get more resource details."
|
|
1629
|
+
),
|
|
1630
|
+
issues: zod.array(
|
|
1631
|
+
zod.object({
|
|
1632
|
+
issueId: zod.number().min(1).describe("The Jira issue ID"),
|
|
1633
|
+
self: zod.string().url().optional().describe(
|
|
1634
|
+
"The Zephyr REST API endpoint relative to the link between the entity and the Jira issue."
|
|
1635
|
+
),
|
|
1636
|
+
id: zod.number().min(1).optional().describe(
|
|
1637
|
+
"The ID that represents the link between the entity and the Jira issue."
|
|
1638
|
+
),
|
|
1639
|
+
target: zod.string().url().optional().describe(
|
|
1640
|
+
"The Jira Cloud REST API endpoint to get the full representation of the issue"
|
|
1641
|
+
),
|
|
1642
|
+
type: zod.enum(["COVERAGE", "BLOCKS", "RELATED"]).optional().describe("The link type")
|
|
1643
|
+
}).strict()
|
|
1644
|
+
).optional().describe("A list of Jira issues linked to this entity"),
|
|
1645
|
+
webLinks: zod.array(
|
|
1646
|
+
zod.object({
|
|
1647
|
+
description: zod.string().optional().describe("The web link description"),
|
|
1648
|
+
url: zod.string().describe("The web link URL"),
|
|
1649
|
+
self: zod.string().url().optional().describe(
|
|
1650
|
+
"The Zephyr REST API endpoint relative to the link between the entity and this web link."
|
|
1651
|
+
),
|
|
1652
|
+
id: zod.number().min(1).optional().describe("The ID of the entity"),
|
|
1653
|
+
type: zod.enum(["COVERAGE", "BLOCKS", "RELATED"]).optional().describe("The link type")
|
|
1654
|
+
}).strict()
|
|
1655
|
+
).optional().describe("A list of web links for this entity"),
|
|
1656
|
+
testPlans: zod.array(
|
|
1657
|
+
zod.object({
|
|
1658
|
+
id: zod.number().min(1).optional().describe(
|
|
1659
|
+
"The ID that represents the link between the Test Cycle and the Test Plan."
|
|
1660
|
+
),
|
|
1661
|
+
self: zod.string().url().optional().describe(
|
|
1662
|
+
"The Zephyr REST API endpoint relative to the link between the entity and the Jira issue."
|
|
1663
|
+
),
|
|
1664
|
+
testPlanId: zod.number().optional().describe("The ID of the test plan"),
|
|
1665
|
+
type: zod.enum(["COVERAGE", "BLOCKS", "RELATED"]).optional().describe("The link type"),
|
|
1666
|
+
target: zod.string().url().optional().describe(
|
|
1667
|
+
"The Zephyr REST API endpoint to get the full representation of the test plan"
|
|
1668
|
+
)
|
|
1669
|
+
}).strict()
|
|
1670
|
+
).optional().describe("A list of test plans linked to a test cycle")
|
|
1671
|
+
}).strict().optional().describe("Represents all links that a Test Cycle has.")
|
|
1672
|
+
}).strict().describe("Details of a test cycle")
|
|
1673
|
+
).optional()
|
|
1674
|
+
}).strict();
|
|
1675
|
+
zod.union([
|
|
1676
|
+
zod.object({
|
|
1677
|
+
errorCode: zod.number(),
|
|
1678
|
+
message: zod.string()
|
|
1679
|
+
}).strict().describe(
|
|
1680
|
+
"A query parameter failed validation at the API layer (projectKey pattern, or the numeric bounds maxResults >= 1, startAt 0..1000000, folderId >= 1, jiraProjectVersionId >= 1)."
|
|
1681
|
+
),
|
|
1682
|
+
zod.object({
|
|
1683
|
+
errorCode: zod.number(),
|
|
1684
|
+
message: zod.string()
|
|
1685
|
+
}).strict().describe("A numeric query parameter was sent with a non-numeric value.")
|
|
1686
|
+
]);
|
|
1687
|
+
zod.union([
|
|
1688
|
+
zod.object({
|
|
1689
|
+
error: zod.string()
|
|
1690
|
+
}).strict().describe("The Authorization header is missing."),
|
|
1691
|
+
zod.object({
|
|
1692
|
+
error: zod.string()
|
|
1693
|
+
}).strict().describe(
|
|
1694
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
1695
|
+
),
|
|
1696
|
+
zod.object({
|
|
1697
|
+
error: zod.string()
|
|
1698
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
1699
|
+
zod.object({
|
|
1700
|
+
error: zod.string()
|
|
1701
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
1702
|
+
zod.object({
|
|
1703
|
+
error: zod.string()
|
|
1704
|
+
}).strict().describe(
|
|
1705
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
1706
|
+
)
|
|
1707
|
+
]);
|
|
1708
|
+
zod.union([
|
|
1709
|
+
zod.object({
|
|
1710
|
+
errorCode: zod.number(),
|
|
1711
|
+
message: zod.string()
|
|
1712
|
+
}).strict().describe(
|
|
1713
|
+
"The projectKey filter refers to a project that does not exist or is deactivated."
|
|
1714
|
+
),
|
|
1715
|
+
zod.object({
|
|
1716
|
+
errorCode: zod.number(),
|
|
1717
|
+
message: zod.string()
|
|
1718
|
+
}).strict().describe("The folderId filter refers to a folder that does not exist."),
|
|
1719
|
+
zod.object({
|
|
1720
|
+
errorCode: zod.number(),
|
|
1721
|
+
message: zod.string()
|
|
1722
|
+
}).strict().describe(
|
|
1723
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
1724
|
+
),
|
|
1725
|
+
zod.object({
|
|
1726
|
+
errorCode: zod.number(),
|
|
1727
|
+
message: zod.string()
|
|
1728
|
+
}).strict().describe(
|
|
1729
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
1730
|
+
)
|
|
1731
|
+
]);
|
|
1732
|
+
zod.object({
|
|
1733
|
+
errorCode: zod.number(),
|
|
1734
|
+
message: zod.string()
|
|
1735
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
1736
|
+
zod.object({
|
|
1737
|
+
errorCode: zod.number(),
|
|
1738
|
+
message: zod.string()
|
|
1739
|
+
}).strict();
|
|
1740
|
+
const getTestCyclePathTestCycleIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
1741
|
+
const GetTestCycleParams = zod.object({
|
|
1742
|
+
testCycleIdOrKey: zod.string().regex(getTestCyclePathTestCycleIdOrKeyRegExp).describe("The ID or key of the test cycle.")
|
|
1743
|
+
}).strict();
|
|
1744
|
+
const getTestCycle200ResponseKeyRegExp = /([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
1745
|
+
const getTestCycle200ResponseNameRegExp = /^(?!\s*$).+/;
|
|
1746
|
+
const getTestCycle200ResponseOwnerAccountIdRegExp = /^[-:a-zA-Z0-9]{1,128}$/;
|
|
1001
1747
|
const GetTestCycle200Response = zod.object({
|
|
1002
1748
|
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1003
1749
|
key: zod.string().regex(getTestCycle200ResponseKeyRegExp).describe("Unique key of the test cycle"),
|
|
@@ -1081,6 +1827,55 @@ const GetTestCycle200Response = zod.object({
|
|
|
1081
1827
|
).optional().describe("A list of test plans linked to a test cycle")
|
|
1082
1828
|
}).strict().optional().describe("Represents all links that a Test Cycle has.")
|
|
1083
1829
|
}).strict().describe("Details of a test cycle");
|
|
1830
|
+
zod.object({
|
|
1831
|
+
errorCode: zod.number(),
|
|
1832
|
+
message: zod.string()
|
|
1833
|
+
}).strict().describe(
|
|
1834
|
+
"The `testCycleIdOrKey` path parameter does not match the required pattern"
|
|
1835
|
+
);
|
|
1836
|
+
zod.union([
|
|
1837
|
+
zod.object({
|
|
1838
|
+
error: zod.string()
|
|
1839
|
+
}).strict().describe("The Authorization header is missing."),
|
|
1840
|
+
zod.object({
|
|
1841
|
+
error: zod.string()
|
|
1842
|
+
}).strict().describe(
|
|
1843
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
1844
|
+
),
|
|
1845
|
+
zod.object({
|
|
1846
|
+
error: zod.string()
|
|
1847
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
1848
|
+
zod.object({
|
|
1849
|
+
error: zod.string()
|
|
1850
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
1851
|
+
zod.object({
|
|
1852
|
+
error: zod.string()
|
|
1853
|
+
}).strict().describe(
|
|
1854
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
1855
|
+
)
|
|
1856
|
+
]);
|
|
1857
|
+
zod.union([
|
|
1858
|
+
zod.object({
|
|
1859
|
+
errorCode: zod.number(),
|
|
1860
|
+
message: zod.string()
|
|
1861
|
+
}).strict().describe("No test cycle exists with the given id or key."),
|
|
1862
|
+
zod.object({
|
|
1863
|
+
errorCode: zod.number(),
|
|
1864
|
+
message: zod.string()
|
|
1865
|
+
}).strict().describe(
|
|
1866
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
1867
|
+
),
|
|
1868
|
+
zod.object({
|
|
1869
|
+
errorCode: zod.number(),
|
|
1870
|
+
message: zod.string()
|
|
1871
|
+
}).strict().describe(
|
|
1872
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
1873
|
+
)
|
|
1874
|
+
]);
|
|
1875
|
+
zod.object({
|
|
1876
|
+
errorCode: zod.number(),
|
|
1877
|
+
message: zod.string()
|
|
1878
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
1084
1879
|
zod.object({
|
|
1085
1880
|
errorCode: zod.number(),
|
|
1086
1881
|
message: zod.string()
|
|
@@ -1104,23 +1899,154 @@ const UpdateTestCycleBody = zod.object({
|
|
|
1104
1899
|
jiraProjectVersion: zod.number().min(1).nullable().optional().describe(
|
|
1105
1900
|
"ID and Link to fetch information about Jira Project version. Relates to 'Version' or 'Releases' in Jira projects."
|
|
1106
1901
|
),
|
|
1107
|
-
status: zod.object({
|
|
1108
|
-
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1109
|
-
self: zod.string().url().optional().describe("The REST API endpoint to get more resource details.")
|
|
1110
|
-
}).strict().describe("ID and link to the status resource."),
|
|
1111
|
-
folder: zod.number().min(1).nullable().optional().describe("ID and link to the folder resource."),
|
|
1112
|
-
description: zod.string().nullish().describe("Description outlining the scope."),
|
|
1113
|
-
plannedStartDate: zod.string().datetime({}).nullish().describe(
|
|
1114
|
-
"Planned start date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1902
|
+
status: zod.object({
|
|
1903
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
1904
|
+
self: zod.string().url().optional().describe("The REST API endpoint to get more resource details.")
|
|
1905
|
+
}).strict().describe("ID and link to the status resource."),
|
|
1906
|
+
folder: zod.number().min(1).nullable().optional().describe("ID and link to the folder resource."),
|
|
1907
|
+
description: zod.string().nullish().describe("Description outlining the scope."),
|
|
1908
|
+
plannedStartDate: zod.string().datetime({}).nullish().describe(
|
|
1909
|
+
"Planned start date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1910
|
+
),
|
|
1911
|
+
plannedEndDate: zod.string().datetime({}).nullish().describe(
|
|
1912
|
+
"The planned end date of the test cycle. This field cannot be blank. Setting it as null or excluding it from the request will leave the field values unchanged. ISO 8601 Format (i.e., yyyy-MM-dd'T'HH:mm:ss'Z')"
|
|
1913
|
+
),
|
|
1914
|
+
owner: zod.string().regex(updateTestCycleBodyOwnerAccountIdRegExp).nullable().describe("Atlassian Account ID of the Jira user."),
|
|
1915
|
+
customFields: zod.record(zod.string(), zod.unknown()).optional().describe(
|
|
1916
|
+
"Multi-line text fields support HTML and should denote new lines with the \\<br\\> tag.\nDates should be in the format 'yyyy-MM-dd'.\nUsers should have values of Jira User Account IDs.\n"
|
|
1917
|
+
)
|
|
1918
|
+
}).strict();
|
|
1919
|
+
zod.union([
|
|
1920
|
+
zod.object({
|
|
1921
|
+
errorCode: zod.number(),
|
|
1922
|
+
message: zod.string()
|
|
1923
|
+
}).strict().describe(
|
|
1924
|
+
"A request body field failed validation at the API layer (required field missing, pattern mismatch, size, or numeric bound)."
|
|
1925
|
+
),
|
|
1926
|
+
zod.object({
|
|
1927
|
+
errorCode: zod.number(),
|
|
1928
|
+
message: zod.string()
|
|
1929
|
+
}).strict().describe("The request body is not valid JSON."),
|
|
1930
|
+
zod.object({
|
|
1931
|
+
errorCode: zod.number(),
|
|
1932
|
+
message: zod.string()
|
|
1933
|
+
}).strict().describe(
|
|
1934
|
+
"A request body field has the wrong type or format (for example a non-ISO-8601 date)."
|
|
1935
|
+
),
|
|
1936
|
+
zod.object({
|
|
1937
|
+
errorCode: zod.number(),
|
|
1938
|
+
message: zod.string()
|
|
1939
|
+
}).strict().describe(
|
|
1940
|
+
"The `testCycleIdOrKey` path parameter does not match the required pattern"
|
|
1941
|
+
),
|
|
1942
|
+
zod.object({
|
|
1943
|
+
errorCode: zod.number(),
|
|
1944
|
+
message: zod.string()
|
|
1945
|
+
}).strict().describe("The status id does not exist for the project."),
|
|
1946
|
+
zod.object({
|
|
1947
|
+
errorCode: zod.number(),
|
|
1948
|
+
message: zod.string()
|
|
1949
|
+
}).strict().describe(
|
|
1950
|
+
"On update, custom fields were provided but not all of the project's custom fields are present in the request."
|
|
1951
|
+
),
|
|
1952
|
+
zod.object({
|
|
1953
|
+
errorCode: zod.number(),
|
|
1954
|
+
message: zod.string()
|
|
1955
|
+
}).strict().describe(
|
|
1956
|
+
"The folderId in the body refers to a folder that does not exist."
|
|
1957
|
+
),
|
|
1958
|
+
zod.object({
|
|
1959
|
+
errorCode: zod.number(),
|
|
1960
|
+
message: zod.string()
|
|
1961
|
+
}).strict().describe(
|
|
1962
|
+
"The folderId refers to a folder that is not a TEST_CYCLE folder."
|
|
1963
|
+
),
|
|
1964
|
+
zod.object({
|
|
1965
|
+
errorCode: zod.number(),
|
|
1966
|
+
message: zod.string()
|
|
1967
|
+
}).strict().describe(
|
|
1968
|
+
"A custom field name in the body does not exist for the project."
|
|
1969
|
+
),
|
|
1970
|
+
zod.object({
|
|
1971
|
+
errorCode: zod.number(),
|
|
1972
|
+
message: zod.string()
|
|
1973
|
+
}).strict().describe(
|
|
1974
|
+
'A custom field value has the wrong type for the field definition. The message names the field and the expected type, e.g. "requires a number value", "requires a string value", "requires a boolean value", "requires a string which is in the format yyyy-MM-dd", or "requires a list".\n'
|
|
1975
|
+
),
|
|
1976
|
+
zod.object({
|
|
1977
|
+
errorCode: zod.number(),
|
|
1978
|
+
message: zod.string()
|
|
1979
|
+
}).strict().describe(
|
|
1980
|
+
"A choice custom field value references an option name that does not exist."
|
|
1981
|
+
),
|
|
1982
|
+
zod.object({
|
|
1983
|
+
errorCode: zod.number(),
|
|
1984
|
+
message: zod.string()
|
|
1985
|
+
}).strict().describe(
|
|
1986
|
+
"A required custom field was provided with a null or empty value."
|
|
1115
1987
|
),
|
|
1116
|
-
|
|
1117
|
-
|
|
1988
|
+
zod.object({
|
|
1989
|
+
errorCode: zod.number(),
|
|
1990
|
+
message: zod.string()
|
|
1991
|
+
}).strict().describe(
|
|
1992
|
+
"A required multi-choice custom field was set to an empty collection."
|
|
1993
|
+
)
|
|
1994
|
+
]);
|
|
1995
|
+
zod.union([
|
|
1996
|
+
zod.object({
|
|
1997
|
+
error: zod.string()
|
|
1998
|
+
}).strict().describe("The Authorization header is missing."),
|
|
1999
|
+
zod.object({
|
|
2000
|
+
error: zod.string()
|
|
2001
|
+
}).strict().describe(
|
|
2002
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
1118
2003
|
),
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
2004
|
+
zod.object({
|
|
2005
|
+
error: zod.string()
|
|
2006
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
2007
|
+
zod.object({
|
|
2008
|
+
error: zod.string()
|
|
2009
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
2010
|
+
zod.object({
|
|
2011
|
+
error: zod.string()
|
|
2012
|
+
}).strict().describe(
|
|
2013
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
1122
2014
|
)
|
|
1123
|
-
|
|
2015
|
+
]);
|
|
2016
|
+
zod.union([
|
|
2017
|
+
zod.object({
|
|
2018
|
+
errorCode: zod.number(),
|
|
2019
|
+
message: zod.string()
|
|
2020
|
+
}).strict().describe(
|
|
2021
|
+
"The caller lacks a required Zephyr permission (when the project's permission system is enabled)."
|
|
2022
|
+
),
|
|
2023
|
+
zod.object({
|
|
2024
|
+
errorCode: zod.number(),
|
|
2025
|
+
message: zod.string()
|
|
2026
|
+
}).strict().describe("Referenced custom fields do not belong to the current client.")
|
|
2027
|
+
]);
|
|
2028
|
+
zod.union([
|
|
2029
|
+
zod.object({
|
|
2030
|
+
errorCode: zod.number(),
|
|
2031
|
+
message: zod.string()
|
|
2032
|
+
}).strict().describe("No test cycle exists with the given id or key."),
|
|
2033
|
+
zod.object({
|
|
2034
|
+
errorCode: zod.number(),
|
|
2035
|
+
message: zod.string()
|
|
2036
|
+
}).strict().describe(
|
|
2037
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
2038
|
+
),
|
|
2039
|
+
zod.object({
|
|
2040
|
+
errorCode: zod.number(),
|
|
2041
|
+
message: zod.string()
|
|
2042
|
+
}).strict().describe(
|
|
2043
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
2044
|
+
)
|
|
2045
|
+
]);
|
|
2046
|
+
zod.object({
|
|
2047
|
+
errorCode: zod.number(),
|
|
2048
|
+
message: zod.string()
|
|
2049
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
1124
2050
|
zod.object({
|
|
1125
2051
|
errorCode: zod.number(),
|
|
1126
2052
|
message: zod.string()
|
|
@@ -1173,6 +2099,55 @@ const GetTestCycleLinks200Response = zod.object({
|
|
|
1173
2099
|
}).strict()
|
|
1174
2100
|
).optional().describe("A list of test plans linked to a test cycle")
|
|
1175
2101
|
}).strict().describe("Represents all links that a Test Cycle has.");
|
|
2102
|
+
zod.object({
|
|
2103
|
+
errorCode: zod.number(),
|
|
2104
|
+
message: zod.string()
|
|
2105
|
+
}).strict().describe(
|
|
2106
|
+
"The `testCycleIdOrKey` path parameter does not match the required pattern"
|
|
2107
|
+
);
|
|
2108
|
+
zod.union([
|
|
2109
|
+
zod.object({
|
|
2110
|
+
error: zod.string()
|
|
2111
|
+
}).strict().describe("The Authorization header is missing."),
|
|
2112
|
+
zod.object({
|
|
2113
|
+
error: zod.string()
|
|
2114
|
+
}).strict().describe(
|
|
2115
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
2116
|
+
),
|
|
2117
|
+
zod.object({
|
|
2118
|
+
error: zod.string()
|
|
2119
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
2120
|
+
zod.object({
|
|
2121
|
+
error: zod.string()
|
|
2122
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
2123
|
+
zod.object({
|
|
2124
|
+
error: zod.string()
|
|
2125
|
+
}).strict().describe(
|
|
2126
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
2127
|
+
)
|
|
2128
|
+
]);
|
|
2129
|
+
zod.union([
|
|
2130
|
+
zod.object({
|
|
2131
|
+
errorCode: zod.number(),
|
|
2132
|
+
message: zod.string()
|
|
2133
|
+
}).strict().describe("No test cycle exists with the given id or key."),
|
|
2134
|
+
zod.object({
|
|
2135
|
+
errorCode: zod.number(),
|
|
2136
|
+
message: zod.string()
|
|
2137
|
+
}).strict().describe(
|
|
2138
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
2139
|
+
),
|
|
2140
|
+
zod.object({
|
|
2141
|
+
errorCode: zod.number(),
|
|
2142
|
+
message: zod.string()
|
|
2143
|
+
}).strict().describe(
|
|
2144
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
2145
|
+
)
|
|
2146
|
+
]);
|
|
2147
|
+
zod.object({
|
|
2148
|
+
errorCode: zod.number(),
|
|
2149
|
+
message: zod.string()
|
|
2150
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
1176
2151
|
zod.object({
|
|
1177
2152
|
errorCode: zod.number(),
|
|
1178
2153
|
message: zod.string()
|
|
@@ -1184,6 +2159,91 @@ const CreateTestCycleIssueLinkParams = zod.object({
|
|
|
1184
2159
|
const CreateTestCycleIssueLinkBody = zod.object({
|
|
1185
2160
|
issueId: zod.number().min(1).describe("The Jira issue ID")
|
|
1186
2161
|
}).strict();
|
|
2162
|
+
zod.union([
|
|
2163
|
+
zod.object({
|
|
2164
|
+
errorCode: zod.number(),
|
|
2165
|
+
message: zod.string()
|
|
2166
|
+
}).strict().describe(
|
|
2167
|
+
"The `testCycleIdOrKey` path parameter does not match the required pattern"
|
|
2168
|
+
),
|
|
2169
|
+
zod.object({
|
|
2170
|
+
errorCode: zod.number(),
|
|
2171
|
+
message: zod.string()
|
|
2172
|
+
}).strict().describe(
|
|
2173
|
+
"A request body field failed validation at the API layer (required field missing, pattern mismatch, size, or numeric bound)."
|
|
2174
|
+
),
|
|
2175
|
+
zod.object({
|
|
2176
|
+
errorCode: zod.number(),
|
|
2177
|
+
message: zod.string()
|
|
2178
|
+
}).strict().describe("The request body is not valid JSON."),
|
|
2179
|
+
zod.object({
|
|
2180
|
+
errorCode: zod.number(),
|
|
2181
|
+
message: zod.string()
|
|
2182
|
+
}).strict().describe(
|
|
2183
|
+
"A request body field has the wrong type or format (for example a non-ISO-8601 date)."
|
|
2184
|
+
),
|
|
2185
|
+
zod.object({
|
|
2186
|
+
errorCode: zod.number(),
|
|
2187
|
+
message: zod.string()
|
|
2188
|
+
}).strict().describe(
|
|
2189
|
+
"An issue link of the requested type already exists between the test cycle and the Jira issue."
|
|
2190
|
+
)
|
|
2191
|
+
]);
|
|
2192
|
+
zod.union([
|
|
2193
|
+
zod.object({
|
|
2194
|
+
error: zod.string()
|
|
2195
|
+
}).strict().describe("The Authorization header is missing."),
|
|
2196
|
+
zod.object({
|
|
2197
|
+
error: zod.string()
|
|
2198
|
+
}).strict().describe(
|
|
2199
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
2200
|
+
),
|
|
2201
|
+
zod.object({
|
|
2202
|
+
error: zod.string()
|
|
2203
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
2204
|
+
zod.object({
|
|
2205
|
+
error: zod.string()
|
|
2206
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
2207
|
+
zod.object({
|
|
2208
|
+
error: zod.string()
|
|
2209
|
+
}).strict().describe(
|
|
2210
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
2211
|
+
)
|
|
2212
|
+
]);
|
|
2213
|
+
zod.object({
|
|
2214
|
+
errorCode: zod.number(),
|
|
2215
|
+
message: zod.string()
|
|
2216
|
+
}).strict().describe(
|
|
2217
|
+
"The caller lacks a required Zephyr permission (when the project's permission system is enabled)."
|
|
2218
|
+
);
|
|
2219
|
+
zod.union([
|
|
2220
|
+
zod.object({
|
|
2221
|
+
errorCode: zod.number(),
|
|
2222
|
+
message: zod.string()
|
|
2223
|
+
}).strict().describe("No test cycle exists with the given id or key."),
|
|
2224
|
+
zod.object({
|
|
2225
|
+
errorCode: zod.number(),
|
|
2226
|
+
message: zod.string()
|
|
2227
|
+
}).strict().describe(
|
|
2228
|
+
"A referenced Jira entity (e.g. jiraProjectVersion) does not exist or is not accessible."
|
|
2229
|
+
),
|
|
2230
|
+
zod.object({
|
|
2231
|
+
errorCode: zod.number(),
|
|
2232
|
+
message: zod.string()
|
|
2233
|
+
}).strict().describe(
|
|
2234
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
2235
|
+
),
|
|
2236
|
+
zod.object({
|
|
2237
|
+
errorCode: zod.number(),
|
|
2238
|
+
message: zod.string()
|
|
2239
|
+
}).strict().describe(
|
|
2240
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
2241
|
+
)
|
|
2242
|
+
]);
|
|
2243
|
+
zod.object({
|
|
2244
|
+
errorCode: zod.number(),
|
|
2245
|
+
message: zod.string()
|
|
2246
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
1187
2247
|
zod.object({
|
|
1188
2248
|
errorCode: zod.number(),
|
|
1189
2249
|
message: zod.string()
|
|
@@ -1196,6 +2256,162 @@ const CreateTestCycleWebLinkBody = zod.object({
|
|
|
1196
2256
|
description: zod.string().optional().describe("The web link description"),
|
|
1197
2257
|
url: zod.string().describe("The web link URL")
|
|
1198
2258
|
}).strict();
|
|
2259
|
+
zod.union([
|
|
2260
|
+
zod.object({
|
|
2261
|
+
errorCode: zod.number(),
|
|
2262
|
+
message: zod.string()
|
|
2263
|
+
}).strict().describe(
|
|
2264
|
+
"The `testCycleIdOrKey` path parameter does not match the required pattern"
|
|
2265
|
+
),
|
|
2266
|
+
zod.object({
|
|
2267
|
+
errorCode: zod.number(),
|
|
2268
|
+
message: zod.string()
|
|
2269
|
+
}).strict().describe(
|
|
2270
|
+
"A request body field failed validation at the API layer (required field missing, pattern mismatch, size, or numeric bound)."
|
|
2271
|
+
),
|
|
2272
|
+
zod.object({
|
|
2273
|
+
errorCode: zod.number(),
|
|
2274
|
+
message: zod.string()
|
|
2275
|
+
}).strict().describe("The request body is not valid JSON."),
|
|
2276
|
+
zod.object({
|
|
2277
|
+
errorCode: zod.number(),
|
|
2278
|
+
message: zod.string()
|
|
2279
|
+
}).strict().describe("No test cycle exists with the given id or key.")
|
|
2280
|
+
]);
|
|
2281
|
+
zod.union([
|
|
2282
|
+
zod.object({
|
|
2283
|
+
error: zod.string()
|
|
2284
|
+
}).strict().describe("The Authorization header is missing."),
|
|
2285
|
+
zod.object({
|
|
2286
|
+
error: zod.string()
|
|
2287
|
+
}).strict().describe(
|
|
2288
|
+
"The bearer token does not have the three dot-separated parts of a JWT."
|
|
2289
|
+
),
|
|
2290
|
+
zod.object({
|
|
2291
|
+
error: zod.string()
|
|
2292
|
+
}).strict().describe("A segment of the bearer token is not valid base64."),
|
|
2293
|
+
zod.object({
|
|
2294
|
+
error: zod.string()
|
|
2295
|
+
}).strict().describe("A decoded segment of the bearer token is not valid JSON."),
|
|
2296
|
+
zod.object({
|
|
2297
|
+
error: zod.string()
|
|
2298
|
+
}).strict().describe(
|
|
2299
|
+
"The JWT is well-formed but its signature could not be verified (wrong secret, tampered, or unknown issuer)."
|
|
2300
|
+
)
|
|
2301
|
+
]);
|
|
2302
|
+
zod.object({
|
|
2303
|
+
errorCode: zod.number(),
|
|
2304
|
+
message: zod.string()
|
|
2305
|
+
}).strict().describe(
|
|
2306
|
+
"The caller lacks a required Zephyr permission (when the project's permission system is enabled)."
|
|
2307
|
+
);
|
|
2308
|
+
zod.union([
|
|
2309
|
+
zod.object({
|
|
2310
|
+
errorCode: zod.number(),
|
|
2311
|
+
message: zod.string()
|
|
2312
|
+
}).strict().describe(
|
|
2313
|
+
"The referenced resource does not exist, or the caller does not have access to its project."
|
|
2314
|
+
),
|
|
2315
|
+
zod.object({
|
|
2316
|
+
errorCode: zod.number(),
|
|
2317
|
+
message: zod.string()
|
|
2318
|
+
}).strict().describe(
|
|
2319
|
+
"The referenced resource belongs to a disabled project, or a project that does not exist."
|
|
2320
|
+
)
|
|
2321
|
+
]);
|
|
2322
|
+
zod.object({
|
|
2323
|
+
errorCode: zod.number(),
|
|
2324
|
+
message: zod.string()
|
|
2325
|
+
}).strict().describe("The backend service returned a 5xx or could not be reached.");
|
|
2326
|
+
zod.object({
|
|
2327
|
+
errorCode: zod.number(),
|
|
2328
|
+
message: zod.string()
|
|
2329
|
+
}).strict();
|
|
2330
|
+
const getTestCycleAttachmentPathTestCycleIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
2331
|
+
zod.object({
|
|
2332
|
+
testCycleIdOrKey: zod.string().regex(getTestCycleAttachmentPathTestCycleIdOrKeyRegExp).describe("The ID or key of the test cycle."),
|
|
2333
|
+
attachmentId: zod.number().min(1).describe("The numeric ID of the attachment.")
|
|
2334
|
+
}).strict();
|
|
2335
|
+
zod.object({
|
|
2336
|
+
errorCode: zod.number(),
|
|
2337
|
+
message: zod.string()
|
|
2338
|
+
}).strict();
|
|
2339
|
+
zod.object({
|
|
2340
|
+
errorCode: zod.number(),
|
|
2341
|
+
message: zod.string()
|
|
2342
|
+
}).strict();
|
|
2343
|
+
zod.object({
|
|
2344
|
+
errorCode: zod.number(),
|
|
2345
|
+
message: zod.string()
|
|
2346
|
+
}).strict();
|
|
2347
|
+
zod.object({
|
|
2348
|
+
errorCode: zod.number(),
|
|
2349
|
+
message: zod.string()
|
|
2350
|
+
}).strict();
|
|
2351
|
+
zod.object({
|
|
2352
|
+
errorCode: zod.number(),
|
|
2353
|
+
message: zod.string()
|
|
2354
|
+
}).strict();
|
|
2355
|
+
const uploadTestCycleAttachmentPathTestCycleIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
2356
|
+
const uploadTestCycleAttachmentPathFileNameMax = 255;
|
|
2357
|
+
zod.object({
|
|
2358
|
+
testCycleIdOrKey: zod.string().regex(uploadTestCycleAttachmentPathTestCycleIdOrKeyRegExp).describe("The ID or key of the test cycle."),
|
|
2359
|
+
fileName: zod.string().min(1).max(uploadTestCycleAttachmentPathFileNameMax).describe(
|
|
2360
|
+
"The name of the file being uploaded, including its extension (for example, `screenshot.png`).\nThis is used as the attachment's display name. URL-encode any special characters and keep\nthe name to 255 characters or fewer.\n"
|
|
2361
|
+
)
|
|
2362
|
+
}).strict();
|
|
2363
|
+
zod.object({
|
|
2364
|
+
errorCode: zod.number(),
|
|
2365
|
+
message: zod.string()
|
|
2366
|
+
}).strict();
|
|
2367
|
+
zod.object({
|
|
2368
|
+
errorCode: zod.number(),
|
|
2369
|
+
message: zod.string()
|
|
2370
|
+
}).strict();
|
|
2371
|
+
zod.object({
|
|
2372
|
+
errorCode: zod.number(),
|
|
2373
|
+
message: zod.string()
|
|
2374
|
+
}).strict();
|
|
2375
|
+
zod.object({
|
|
2376
|
+
errorCode: zod.number(),
|
|
2377
|
+
message: zod.string()
|
|
2378
|
+
}).strict();
|
|
2379
|
+
zod.object({
|
|
2380
|
+
errorCode: zod.number(),
|
|
2381
|
+
message: zod.string()
|
|
2382
|
+
}).strict();
|
|
2383
|
+
zod.object({
|
|
2384
|
+
errorCode: zod.number(),
|
|
2385
|
+
message: zod.string()
|
|
2386
|
+
}).strict();
|
|
2387
|
+
zod.object({
|
|
2388
|
+
errorCode: zod.number(),
|
|
2389
|
+
message: zod.string()
|
|
2390
|
+
}).strict();
|
|
2391
|
+
const getTestCycleAttachmentsPathTestCycleIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
2392
|
+
zod.object({
|
|
2393
|
+
testCycleIdOrKey: zod.string().regex(getTestCycleAttachmentsPathTestCycleIdOrKeyRegExp).describe("The ID or key of the test cycle.")
|
|
2394
|
+
}).strict();
|
|
2395
|
+
zod.object({
|
|
2396
|
+
attachments: zod.array(
|
|
2397
|
+
zod.object({
|
|
2398
|
+
id: zod.number().optional().describe("Database ID of the attachment."),
|
|
2399
|
+
name: zod.string().optional().describe("File name of the attachment.")
|
|
2400
|
+
}).strict()
|
|
2401
|
+
).optional()
|
|
2402
|
+
}).strict();
|
|
2403
|
+
zod.object({
|
|
2404
|
+
errorCode: zod.number(),
|
|
2405
|
+
message: zod.string()
|
|
2406
|
+
}).strict();
|
|
2407
|
+
zod.object({
|
|
2408
|
+
errorCode: zod.number(),
|
|
2409
|
+
message: zod.string()
|
|
2410
|
+
}).strict();
|
|
2411
|
+
zod.object({
|
|
2412
|
+
errorCode: zod.number(),
|
|
2413
|
+
message: zod.string()
|
|
2414
|
+
}).strict();
|
|
1199
2415
|
zod.object({
|
|
1200
2416
|
errorCode: zod.number(),
|
|
1201
2417
|
message: zod.string()
|
|
@@ -1319,6 +2535,14 @@ zod.object({
|
|
|
1319
2535
|
errorCode: zod.number(),
|
|
1320
2536
|
message: zod.string()
|
|
1321
2537
|
}).strict();
|
|
2538
|
+
zod.object({
|
|
2539
|
+
errorCode: zod.number(),
|
|
2540
|
+
message: zod.string()
|
|
2541
|
+
}).strict();
|
|
2542
|
+
zod.object({
|
|
2543
|
+
errorCode: zod.number(),
|
|
2544
|
+
message: zod.string()
|
|
2545
|
+
}).strict();
|
|
1322
2546
|
const createTestPlanBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
1323
2547
|
const createTestPlanBodyNameMax = 255;
|
|
1324
2548
|
const createTestPlanBodyNameRegExp = /^(?!\\s*$).+/;
|
|
@@ -1346,6 +2570,130 @@ zod.object({
|
|
|
1346
2570
|
errorCode: zod.number(),
|
|
1347
2571
|
message: zod.string()
|
|
1348
2572
|
}).strict();
|
|
2573
|
+
zod.object({
|
|
2574
|
+
errorCode: zod.number(),
|
|
2575
|
+
message: zod.string()
|
|
2576
|
+
}).strict();
|
|
2577
|
+
zod.object({
|
|
2578
|
+
errorCode: zod.number(),
|
|
2579
|
+
message: zod.string()
|
|
2580
|
+
}).strict();
|
|
2581
|
+
const listTestPlansCursorPaginatedQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2582
|
+
const listTestPlansCursorPaginatedQueryLimitDefault = 10;
|
|
2583
|
+
const listTestPlansCursorPaginatedQueryLimitMax = 1e3;
|
|
2584
|
+
const listTestPlansCursorPaginatedQueryStartAtIdDefault = 0;
|
|
2585
|
+
const listTestPlansCursorPaginatedQueryStartAtIdMin = 0;
|
|
2586
|
+
zod.object({
|
|
2587
|
+
projectKey: zod.string().regex(listTestPlansCursorPaginatedQueryProjectKeyRegExp).optional().describe("Jira project key filter"),
|
|
2588
|
+
limit: zod.number().min(1).max(listTestPlansCursorPaginatedQueryLimitMax).default(listTestPlansCursorPaginatedQueryLimitDefault).describe(
|
|
2589
|
+
"Specifies the maximum number of results to return in a single call. The default value is 10, and the maximum value that can be requested is 1000.\n\nNote that the server may enforce a lower limit than requested, depending on resource availability or other internal constraints. If this happens, the result set may be truncated. Always check the limit value in the response to confirm how many results were actually returned.\n"
|
|
2590
|
+
),
|
|
2591
|
+
startAtId: zod.number().min(listTestPlansCursorPaginatedQueryStartAtIdMin).default(listTestPlansCursorPaginatedQueryStartAtIdDefault).describe("Zero-indexed starting position for ID-based pagination."),
|
|
2592
|
+
updatedAfter: zod.string().datetime({}).optional().describe(
|
|
2593
|
+
"Filter only entities updated after the given time. Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
|
|
2594
|
+
)
|
|
2595
|
+
});
|
|
2596
|
+
const listTestPlansCursorPaginated200ResponseOneNextStartAtIdMin = 0;
|
|
2597
|
+
const listTestPlansCursorPaginated200ResponseOneLimitMin = 0;
|
|
2598
|
+
const listTestPlansCursorPaginated200ResponseTwoValuesItemKeyRegExp = /.+-P[0-9]+/;
|
|
2599
|
+
const listTestPlansCursorPaginated200ResponseTwoValuesItemNameMax = 255;
|
|
2600
|
+
const listTestPlansCursorPaginated200ResponseTwoValuesItemNameRegExp = /^(?!\\s*$).+/;
|
|
2601
|
+
const listTestPlansCursorPaginated200ResponseTwoValuesItemOwnerAccountIdRegExp = /^[-:a-zA-Z0-9]{1,128}$/;
|
|
2602
|
+
const listTestPlansCursorPaginated200ResponseTwoValuesItemLabelsMax = 50;
|
|
2603
|
+
zod.object({
|
|
2604
|
+
next: zod.string().url().nullish(),
|
|
2605
|
+
nextStartAtId: zod.number().min(listTestPlansCursorPaginated200ResponseOneNextStartAtIdMin).nullable(),
|
|
2606
|
+
limit: zod.number().min(listTestPlansCursorPaginated200ResponseOneLimitMin),
|
|
2607
|
+
values: zod.array(
|
|
2608
|
+
zod.object({
|
|
2609
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
2610
|
+
key: zod.string().regex(
|
|
2611
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemKeyRegExp
|
|
2612
|
+
).describe("Key of the test plan"),
|
|
2613
|
+
name: zod.string().min(1).max(listTestPlansCursorPaginated200ResponseTwoValuesItemNameMax).regex(
|
|
2614
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemNameRegExp
|
|
2615
|
+
),
|
|
2616
|
+
objective: zod.string().nullish().describe("A description of the objective."),
|
|
2617
|
+
project: zod.object({
|
|
2618
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
2619
|
+
self: zod.string().url().optional().describe(
|
|
2620
|
+
"The REST API endpoint to get more resource details."
|
|
2621
|
+
)
|
|
2622
|
+
}).strict().describe("ID and link relative to Zephyr project."),
|
|
2623
|
+
status: zod.object({
|
|
2624
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
2625
|
+
self: zod.string().url().optional().describe(
|
|
2626
|
+
"The REST API endpoint to get more resource details."
|
|
2627
|
+
)
|
|
2628
|
+
}).strict().describe("ID and link to the status resource."),
|
|
2629
|
+
folder: zod.object({
|
|
2630
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
2631
|
+
self: zod.string().url().optional().describe(
|
|
2632
|
+
"The REST API endpoint to get more resource details."
|
|
2633
|
+
)
|
|
2634
|
+
}).strict().nullish().describe("ID and link to the folder resource."),
|
|
2635
|
+
owner: zod.object({
|
|
2636
|
+
accountId: zod.string().regex(
|
|
2637
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemOwnerAccountIdRegExp
|
|
2638
|
+
).nullable().describe("Atlassian Account ID of the Jira user."),
|
|
2639
|
+
self: zod.string().url().optional().describe(
|
|
2640
|
+
"The Jira REST API endpoint to get the full representation of the Jira user."
|
|
2641
|
+
)
|
|
2642
|
+
}).strict().nullish(),
|
|
2643
|
+
customFields: zod.record(zod.string(), zod.unknown()).optional().describe(
|
|
2644
|
+
"Multi-line text fields support HTML and should denote new lines with the \\<br\\> tag.\nDates should be in the format 'yyyy-MM-dd'.\nUsers should have values of Jira User Account IDs.\n"
|
|
2645
|
+
),
|
|
2646
|
+
labels: zod.array(zod.string()).max(
|
|
2647
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemLabelsMax
|
|
2648
|
+
).optional().describe("Array of labels associated to this entity."),
|
|
2649
|
+
links: zod.object({
|
|
2650
|
+
webLinks: zod.array(
|
|
2651
|
+
zod.object({
|
|
2652
|
+
description: zod.string().optional().describe("The web link description"),
|
|
2653
|
+
url: zod.string().describe("The web link URL"),
|
|
2654
|
+
self: zod.string().url().optional().describe(
|
|
2655
|
+
"The Zephyr REST API endpoint relative to the link between the entity and this web link."
|
|
2656
|
+
),
|
|
2657
|
+
id: zod.number().min(1).optional().describe("The ID of the entity"),
|
|
2658
|
+
type: zod.enum(["COVERAGE", "BLOCKS", "RELATED"]).optional().describe("The link type")
|
|
2659
|
+
}).strict()
|
|
2660
|
+
).optional().describe("A list of web links for this entity"),
|
|
2661
|
+
issues: zod.array(
|
|
2662
|
+
zod.object({
|
|
2663
|
+
issueId: zod.number().min(1).describe("The Jira issue ID"),
|
|
2664
|
+
self: zod.string().url().optional().describe(
|
|
2665
|
+
"The Zephyr REST API endpoint relative to the link between the entity and the Jira issue."
|
|
2666
|
+
),
|
|
2667
|
+
id: zod.number().min(1).optional().describe(
|
|
2668
|
+
"The ID that represents the link between the entity and the Jira issue."
|
|
2669
|
+
),
|
|
2670
|
+
target: zod.string().url().optional().describe(
|
|
2671
|
+
"The Jira Cloud REST API endpoint to get the full representation of the issue"
|
|
2672
|
+
),
|
|
2673
|
+
type: zod.enum(["COVERAGE", "BLOCKS", "RELATED"]).optional().describe("The link type")
|
|
2674
|
+
}).strict()
|
|
2675
|
+
).optional().describe("A list of Jira issues linked to this entity"),
|
|
2676
|
+
testCycles: zod.array(
|
|
2677
|
+
zod.object({
|
|
2678
|
+
id: zod.number().min(1).describe("The ID of the entity"),
|
|
2679
|
+
self: zod.string().url().optional().describe(
|
|
2680
|
+
"The REST API endpoint to get more resource details."
|
|
2681
|
+
),
|
|
2682
|
+
testCycleId: zod.number().min(1).optional().describe("The ID of the entity"),
|
|
2683
|
+
type: zod.enum(["COVERAGE", "BLOCKS", "RELATED"]).optional().describe("The link type"),
|
|
2684
|
+
target: zod.string().optional().describe("The test cycle resource")
|
|
2685
|
+
}).strict().describe(
|
|
2686
|
+
"ID and link to a test cycle associated with a test plan."
|
|
2687
|
+
)
|
|
2688
|
+
).optional().describe("A list of test cycle links for a test plan")
|
|
2689
|
+
}).strict().optional()
|
|
2690
|
+
}).strict()
|
|
2691
|
+
).optional()
|
|
2692
|
+
}).strict();
|
|
2693
|
+
zod.object({
|
|
2694
|
+
errorCode: zod.number(),
|
|
2695
|
+
message: zod.string()
|
|
2696
|
+
}).strict();
|
|
1349
2697
|
const getTestPlanPathTestPlanIdOrKeyRegExp = /([0-9]+)|(.+-P[0-9]+)/;
|
|
1350
2698
|
zod.object({
|
|
1351
2699
|
testPlanIdOrKey: zod.string().regex(getTestPlanPathTestPlanIdOrKeyRegExp).describe(
|
|
@@ -1430,6 +2778,18 @@ zod.object({
|
|
|
1430
2778
|
errorCode: zod.number(),
|
|
1431
2779
|
message: zod.string()
|
|
1432
2780
|
}).strict();
|
|
2781
|
+
zod.object({
|
|
2782
|
+
errorCode: zod.number(),
|
|
2783
|
+
message: zod.string()
|
|
2784
|
+
}).strict();
|
|
2785
|
+
zod.object({
|
|
2786
|
+
errorCode: zod.number(),
|
|
2787
|
+
message: zod.string()
|
|
2788
|
+
}).strict();
|
|
2789
|
+
zod.object({
|
|
2790
|
+
errorCode: zod.number(),
|
|
2791
|
+
message: zod.string()
|
|
2792
|
+
}).strict();
|
|
1433
2793
|
const createTestPlanWebLinkPathTestPlanIdOrKeyRegExp = /([0-9]+)|(.+-P[0-9]+)/;
|
|
1434
2794
|
zod.object({
|
|
1435
2795
|
testPlanIdOrKey: zod.string().regex(createTestPlanWebLinkPathTestPlanIdOrKeyRegExp).describe(
|
|
@@ -1448,6 +2808,18 @@ zod.object({
|
|
|
1448
2808
|
errorCode: zod.number(),
|
|
1449
2809
|
message: zod.string()
|
|
1450
2810
|
}).strict();
|
|
2811
|
+
zod.object({
|
|
2812
|
+
errorCode: zod.number(),
|
|
2813
|
+
message: zod.string()
|
|
2814
|
+
}).strict();
|
|
2815
|
+
zod.object({
|
|
2816
|
+
errorCode: zod.number(),
|
|
2817
|
+
message: zod.string()
|
|
2818
|
+
}).strict();
|
|
2819
|
+
zod.object({
|
|
2820
|
+
errorCode: zod.number(),
|
|
2821
|
+
message: zod.string()
|
|
2822
|
+
}).strict();
|
|
1451
2823
|
const createTestPlanIssueLinkPathTestPlanIdOrKeyRegExp = /([0-9]+)|(.+-P[0-9]+)/;
|
|
1452
2824
|
zod.object({
|
|
1453
2825
|
testPlanIdOrKey: zod.string().regex(createTestPlanIssueLinkPathTestPlanIdOrKeyRegExp).describe(
|
|
@@ -1465,6 +2837,18 @@ zod.object({
|
|
|
1465
2837
|
errorCode: zod.number(),
|
|
1466
2838
|
message: zod.string()
|
|
1467
2839
|
}).strict();
|
|
2840
|
+
zod.object({
|
|
2841
|
+
errorCode: zod.number(),
|
|
2842
|
+
message: zod.string()
|
|
2843
|
+
}).strict();
|
|
2844
|
+
zod.object({
|
|
2845
|
+
errorCode: zod.number(),
|
|
2846
|
+
message: zod.string()
|
|
2847
|
+
}).strict();
|
|
2848
|
+
zod.object({
|
|
2849
|
+
errorCode: zod.number(),
|
|
2850
|
+
message: zod.string()
|
|
2851
|
+
}).strict();
|
|
1468
2852
|
const createTestPlanTestCycleLinkPathTestPlanIdOrKeyRegExp = /([0-9]+)|(.+-P[0-9]+)/;
|
|
1469
2853
|
zod.object({
|
|
1470
2854
|
testPlanIdOrKey: zod.string().regex(createTestPlanTestCycleLinkPathTestPlanIdOrKeyRegExp).describe(
|
|
@@ -1483,6 +2867,112 @@ zod.object({
|
|
|
1483
2867
|
errorCode: zod.number(),
|
|
1484
2868
|
message: zod.string()
|
|
1485
2869
|
}).strict();
|
|
2870
|
+
zod.object({
|
|
2871
|
+
errorCode: zod.number(),
|
|
2872
|
+
message: zod.string()
|
|
2873
|
+
}).strict();
|
|
2874
|
+
zod.object({
|
|
2875
|
+
errorCode: zod.number(),
|
|
2876
|
+
message: zod.string()
|
|
2877
|
+
}).strict();
|
|
2878
|
+
zod.object({
|
|
2879
|
+
errorCode: zod.number(),
|
|
2880
|
+
message: zod.string()
|
|
2881
|
+
}).strict();
|
|
2882
|
+
const getTestPlanAttachmentPathTestPlanIdOrKeyRegExp = /([0-9]+)|(.+-P[0-9]+)/;
|
|
2883
|
+
zod.object({
|
|
2884
|
+
testPlanIdOrKey: zod.string().regex(getTestPlanAttachmentPathTestPlanIdOrKeyRegExp).describe(
|
|
2885
|
+
"The ID or key of the test plan. Test plan keys are of the format [A-Z]+-P[0-9]+"
|
|
2886
|
+
),
|
|
2887
|
+
attachmentId: zod.number().min(1).describe("The numeric ID of the attachment.")
|
|
2888
|
+
}).strict();
|
|
2889
|
+
zod.object({
|
|
2890
|
+
errorCode: zod.number(),
|
|
2891
|
+
message: zod.string()
|
|
2892
|
+
}).strict();
|
|
2893
|
+
zod.object({
|
|
2894
|
+
errorCode: zod.number(),
|
|
2895
|
+
message: zod.string()
|
|
2896
|
+
}).strict();
|
|
2897
|
+
zod.object({
|
|
2898
|
+
errorCode: zod.number(),
|
|
2899
|
+
message: zod.string()
|
|
2900
|
+
}).strict();
|
|
2901
|
+
zod.object({
|
|
2902
|
+
errorCode: zod.number(),
|
|
2903
|
+
message: zod.string()
|
|
2904
|
+
}).strict();
|
|
2905
|
+
zod.object({
|
|
2906
|
+
errorCode: zod.number(),
|
|
2907
|
+
message: zod.string()
|
|
2908
|
+
}).strict();
|
|
2909
|
+
zod.object({
|
|
2910
|
+
testPlanIdOrKey: zod.string().describe(
|
|
2911
|
+
"The ID or key of the test plan. Test plan keys are of the format [A-Z]+-P[0-9]+"
|
|
2912
|
+
)
|
|
2913
|
+
}).strict();
|
|
2914
|
+
zod.object({
|
|
2915
|
+
attachments: zod.array(
|
|
2916
|
+
zod.object({
|
|
2917
|
+
id: zod.number().optional().describe("Database ID of the attachment."),
|
|
2918
|
+
name: zod.string().optional().describe("File name of the attachment.")
|
|
2919
|
+
}).strict()
|
|
2920
|
+
).optional()
|
|
2921
|
+
}).strict();
|
|
2922
|
+
zod.object({
|
|
2923
|
+
errorCode: zod.number(),
|
|
2924
|
+
message: zod.string()
|
|
2925
|
+
}).strict();
|
|
2926
|
+
zod.object({
|
|
2927
|
+
errorCode: zod.number(),
|
|
2928
|
+
message: zod.string()
|
|
2929
|
+
}).strict();
|
|
2930
|
+
zod.object({
|
|
2931
|
+
errorCode: zod.number(),
|
|
2932
|
+
message: zod.string()
|
|
2933
|
+
}).strict();
|
|
2934
|
+
zod.object({
|
|
2935
|
+
errorCode: zod.number(),
|
|
2936
|
+
message: zod.string()
|
|
2937
|
+
}).strict();
|
|
2938
|
+
const createTestPlanAttachmentPathTestPlanIdOrKeyRegExp = /([0-9]+)|(.+-P[0-9]+)/;
|
|
2939
|
+
const createTestPlanAttachmentPathFileNameMax = 255;
|
|
2940
|
+
zod.object({
|
|
2941
|
+
testPlanIdOrKey: zod.string().regex(createTestPlanAttachmentPathTestPlanIdOrKeyRegExp).describe(
|
|
2942
|
+
"The ID or key of the test plan. Test plan keys are of the format [A-Z]+-P[0-9]+"
|
|
2943
|
+
),
|
|
2944
|
+
fileName: zod.string().min(1).max(createTestPlanAttachmentPathFileNameMax).describe(
|
|
2945
|
+
"The name of the file being uploaded, including its extension (for example, `screenshot.png`).\nThis is used as the attachment's display name. URL-encode any special characters and keep\nthe name to 255 characters or fewer.\n"
|
|
2946
|
+
)
|
|
2947
|
+
}).strict();
|
|
2948
|
+
zod.object({
|
|
2949
|
+
errorCode: zod.number(),
|
|
2950
|
+
message: zod.string()
|
|
2951
|
+
}).strict();
|
|
2952
|
+
zod.object({
|
|
2953
|
+
errorCode: zod.number(),
|
|
2954
|
+
message: zod.string()
|
|
2955
|
+
}).strict();
|
|
2956
|
+
zod.object({
|
|
2957
|
+
errorCode: zod.number(),
|
|
2958
|
+
message: zod.string()
|
|
2959
|
+
}).strict();
|
|
2960
|
+
zod.object({
|
|
2961
|
+
errorCode: zod.number(),
|
|
2962
|
+
message: zod.string()
|
|
2963
|
+
}).strict();
|
|
2964
|
+
zod.object({
|
|
2965
|
+
errorCode: zod.number(),
|
|
2966
|
+
message: zod.string()
|
|
2967
|
+
}).strict();
|
|
2968
|
+
zod.object({
|
|
2969
|
+
errorCode: zod.number(),
|
|
2970
|
+
message: zod.string()
|
|
2971
|
+
}).strict();
|
|
2972
|
+
zod.object({
|
|
2973
|
+
errorCode: zod.number(),
|
|
2974
|
+
message: zod.string()
|
|
2975
|
+
}).strict();
|
|
1486
2976
|
const listTestExecutionsQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
1487
2977
|
const listTestExecutionsQueryTestCycleRegExp = /([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
1488
2978
|
const listTestExecutionsQueryTestCaseRegExp = /([0-9]+)|(.+-T[0-9]+)/;
|
|
@@ -1626,6 +3116,14 @@ zod.object({
|
|
|
1626
3116
|
errorCode: zod.number(),
|
|
1627
3117
|
message: zod.string()
|
|
1628
3118
|
}).strict();
|
|
3119
|
+
zod.object({
|
|
3120
|
+
errorCode: zod.number(),
|
|
3121
|
+
message: zod.string()
|
|
3122
|
+
}).strict();
|
|
3123
|
+
zod.object({
|
|
3124
|
+
errorCode: zod.number(),
|
|
3125
|
+
message: zod.string()
|
|
3126
|
+
}).strict();
|
|
1629
3127
|
const createTestExecutionBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
1630
3128
|
const createTestExecutionBodyTestCaseKeyRegExp = /(.+-T[0-9]+)/;
|
|
1631
3129
|
const createTestExecutionBodyTestCycleKeyRegExp = /([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
@@ -1672,6 +3170,14 @@ zod.object({
|
|
|
1672
3170
|
errorCode: zod.number(),
|
|
1673
3171
|
message: zod.string()
|
|
1674
3172
|
}).strict();
|
|
3173
|
+
zod.object({
|
|
3174
|
+
errorCode: zod.number(),
|
|
3175
|
+
message: zod.string()
|
|
3176
|
+
}).strict();
|
|
3177
|
+
zod.object({
|
|
3178
|
+
errorCode: zod.number(),
|
|
3179
|
+
message: zod.string()
|
|
3180
|
+
}).strict();
|
|
1675
3181
|
const listTestExecutionsNextgenQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
1676
3182
|
const listTestExecutionsNextgenQueryTestCycleRegExp = /([A-Z][A-Z_0-9]+-R[0-9]+)/;
|
|
1677
3183
|
const listTestExecutionsNextgenQueryTestCaseRegExp = /([0-9]+)|(.+-T[0-9]+)/;
|
|
@@ -1703,7 +3209,10 @@ const ListTestExecutionsNextgenQueryParams = zod.object({
|
|
|
1703
3209
|
limit: zod.number().min(1).max(listTestExecutionsNextgenQueryLimitMax).default(listTestExecutionsNextgenQueryLimitDefault).describe(
|
|
1704
3210
|
"Specifies the maximum number of results to return in a single call. The default value is 10, and the maximum value that can be requested is 1000.\n\nNote that the server may enforce a lower limit than requested, depending on resource availability or other internal constraints. If this happens, the result set may be truncated. Always check the limit value in the response to confirm how many results were actually returned.\n"
|
|
1705
3211
|
),
|
|
1706
|
-
startAtId: zod.number().min(listTestExecutionsNextgenQueryStartAtIdMin).default(listTestExecutionsNextgenQueryStartAtIdDefault).describe("Zero-indexed starting position for ID-based pagination.")
|
|
3212
|
+
startAtId: zod.number().min(listTestExecutionsNextgenQueryStartAtIdMin).default(listTestExecutionsNextgenQueryStartAtIdDefault).describe("Zero-indexed starting position for ID-based pagination."),
|
|
3213
|
+
updatedAfter: zod.string().datetime({}).optional().describe(
|
|
3214
|
+
"Filter only entities updated after the given time. Format: yyyy-MM-dd'T'HH:mm:ss'Z'"
|
|
3215
|
+
)
|
|
1707
3216
|
});
|
|
1708
3217
|
const listTestExecutionsNextgen200ResponseOneNextStartAtIdMin = 0;
|
|
1709
3218
|
const listTestExecutionsNextgen200ResponseOneLimitMin = 0;
|
|
@@ -1807,6 +3316,14 @@ zod.object({
|
|
|
1807
3316
|
errorCode: zod.number(),
|
|
1808
3317
|
message: zod.string()
|
|
1809
3318
|
}).strict();
|
|
3319
|
+
zod.object({
|
|
3320
|
+
errorCode: zod.number(),
|
|
3321
|
+
message: zod.string()
|
|
3322
|
+
}).strict();
|
|
3323
|
+
zod.object({
|
|
3324
|
+
errorCode: zod.number(),
|
|
3325
|
+
message: zod.string()
|
|
3326
|
+
}).strict();
|
|
1810
3327
|
const getTestExecutionPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
1811
3328
|
const GetTestExecutionParams = zod.object({
|
|
1812
3329
|
testExecutionIdOrKey: zod.string().regex(getTestExecutionPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -1888,6 +3405,18 @@ zod.object({
|
|
|
1888
3405
|
errorCode: zod.number(),
|
|
1889
3406
|
message: zod.string()
|
|
1890
3407
|
}).strict();
|
|
3408
|
+
zod.object({
|
|
3409
|
+
errorCode: zod.number(),
|
|
3410
|
+
message: zod.string()
|
|
3411
|
+
}).strict();
|
|
3412
|
+
zod.object({
|
|
3413
|
+
errorCode: zod.number(),
|
|
3414
|
+
message: zod.string()
|
|
3415
|
+
}).strict();
|
|
3416
|
+
zod.object({
|
|
3417
|
+
errorCode: zod.number(),
|
|
3418
|
+
message: zod.string()
|
|
3419
|
+
}).strict();
|
|
1891
3420
|
const updateTestExecutionPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
1892
3421
|
const UpdateTestExecutionParams = zod.object({
|
|
1893
3422
|
testExecutionIdOrKey: zod.string().regex(updateTestExecutionPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -1913,6 +3442,18 @@ zod.object({
|
|
|
1913
3442
|
errorCode: zod.number(),
|
|
1914
3443
|
message: zod.string()
|
|
1915
3444
|
}).strict();
|
|
3445
|
+
zod.object({
|
|
3446
|
+
errorCode: zod.number(),
|
|
3447
|
+
message: zod.string()
|
|
3448
|
+
}).strict();
|
|
3449
|
+
zod.object({
|
|
3450
|
+
errorCode: zod.number(),
|
|
3451
|
+
message: zod.string()
|
|
3452
|
+
}).strict();
|
|
3453
|
+
zod.object({
|
|
3454
|
+
errorCode: zod.number(),
|
|
3455
|
+
message: zod.string()
|
|
3456
|
+
}).strict();
|
|
1916
3457
|
const getTestExecutionTestStepsPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
1917
3458
|
const GetTestExecutionTestStepsParams = zod.object({
|
|
1918
3459
|
testExecutionIdOrKey: zod.string().regex(getTestExecutionTestStepsPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -1951,6 +3492,7 @@ const GetTestExecutionTestSteps200Response = zod.object({
|
|
|
1951
3492
|
isLast: zod.boolean().optional().describe("Indicates if this is the last page of results."),
|
|
1952
3493
|
values: zod.array(
|
|
1953
3494
|
zod.object({
|
|
3495
|
+
id: zod.number().nullish().describe("The id of the test step (test script result)"),
|
|
1954
3496
|
inline: zod.object({
|
|
1955
3497
|
description: zod.string().nullish().describe("The instruction to be followed"),
|
|
1956
3498
|
testData: zod.string().nullish().describe(
|
|
@@ -1972,6 +3514,18 @@ const GetTestExecutionTestSteps200Response = zod.object({
|
|
|
1972
3514
|
}).strict().describe("Inline test step")
|
|
1973
3515
|
).optional().describe("The list of test steps")
|
|
1974
3516
|
}).strict().describe("Response body when retrieving test steps for a test execution");
|
|
3517
|
+
zod.object({
|
|
3518
|
+
errorCode: zod.number(),
|
|
3519
|
+
message: zod.string()
|
|
3520
|
+
}).strict();
|
|
3521
|
+
zod.object({
|
|
3522
|
+
errorCode: zod.number(),
|
|
3523
|
+
message: zod.string()
|
|
3524
|
+
}).strict();
|
|
3525
|
+
zod.object({
|
|
3526
|
+
errorCode: zod.number(),
|
|
3527
|
+
message: zod.string()
|
|
3528
|
+
}).strict();
|
|
1975
3529
|
const putTestExecutionTestStepsPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
1976
3530
|
const PutTestExecutionTestStepsParams = zod.object({
|
|
1977
3531
|
testExecutionIdOrKey: zod.string().regex(putTestExecutionTestStepsPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -1995,6 +3549,10 @@ zod.object({
|
|
|
1995
3549
|
errorCode: zod.number(),
|
|
1996
3550
|
message: zod.string()
|
|
1997
3551
|
}).strict();
|
|
3552
|
+
zod.object({
|
|
3553
|
+
errorCode: zod.number(),
|
|
3554
|
+
message: zod.string()
|
|
3555
|
+
}).strict();
|
|
1998
3556
|
zod.union([
|
|
1999
3557
|
zod.object({
|
|
2000
3558
|
errorCode: zod.number(),
|
|
@@ -2009,6 +3567,10 @@ zod.object({
|
|
|
2009
3567
|
errorCode: zod.number(),
|
|
2010
3568
|
message: zod.string()
|
|
2011
3569
|
}).strict();
|
|
3570
|
+
zod.object({
|
|
3571
|
+
errorCode: zod.number(),
|
|
3572
|
+
message: zod.string()
|
|
3573
|
+
}).strict();
|
|
2012
3574
|
const syncTestExecutionScriptPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
2013
3575
|
zod.object({
|
|
2014
3576
|
testExecutionIdOrKey: zod.string().regex(syncTestExecutionScriptPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -2030,6 +3592,55 @@ zod.object({
|
|
|
2030
3592
|
errorCode: zod.number(),
|
|
2031
3593
|
message: zod.string()
|
|
2032
3594
|
}).strict();
|
|
3595
|
+
zod.object({
|
|
3596
|
+
errorCode: zod.number(),
|
|
3597
|
+
message: zod.string()
|
|
3598
|
+
}).strict();
|
|
3599
|
+
zod.object({
|
|
3600
|
+
errorCode: zod.number(),
|
|
3601
|
+
message: zod.string()
|
|
3602
|
+
}).strict();
|
|
3603
|
+
const createTestExecutionTestStepAttachmentPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
3604
|
+
const createTestExecutionTestStepAttachmentPathFileNameMax = 255;
|
|
3605
|
+
zod.object({
|
|
3606
|
+
testExecutionIdOrKey: zod.string().regex(
|
|
3607
|
+
createTestExecutionTestStepAttachmentPathTestExecutionIdOrKeyRegExp
|
|
3608
|
+
).describe(
|
|
3609
|
+
"The ID or key of the test execution. Test execution keys are of the format [A-Z]+-E[0-9]+"
|
|
3610
|
+
),
|
|
3611
|
+
testExecutionStepId: zod.number().min(1).describe("The ID of the step within the test execution."),
|
|
3612
|
+
fileName: zod.string().min(1).max(createTestExecutionTestStepAttachmentPathFileNameMax).describe(
|
|
3613
|
+
"The name of the file being uploaded, including its extension (for example, `screenshot.png`).\nThis is used as the attachment's display name. URL-encode any special characters and keep\nthe name to 255 characters or fewer.\n"
|
|
3614
|
+
)
|
|
3615
|
+
}).strict();
|
|
3616
|
+
zod.object({
|
|
3617
|
+
errorCode: zod.number(),
|
|
3618
|
+
message: zod.string()
|
|
3619
|
+
}).strict();
|
|
3620
|
+
zod.object({
|
|
3621
|
+
errorCode: zod.number(),
|
|
3622
|
+
message: zod.string()
|
|
3623
|
+
}).strict();
|
|
3624
|
+
zod.object({
|
|
3625
|
+
errorCode: zod.number(),
|
|
3626
|
+
message: zod.string()
|
|
3627
|
+
}).strict();
|
|
3628
|
+
zod.object({
|
|
3629
|
+
errorCode: zod.number(),
|
|
3630
|
+
message: zod.string()
|
|
3631
|
+
}).strict();
|
|
3632
|
+
zod.object({
|
|
3633
|
+
errorCode: zod.number(),
|
|
3634
|
+
message: zod.string()
|
|
3635
|
+
}).strict();
|
|
3636
|
+
zod.object({
|
|
3637
|
+
errorCode: zod.number(),
|
|
3638
|
+
message: zod.string()
|
|
3639
|
+
}).strict();
|
|
3640
|
+
zod.object({
|
|
3641
|
+
errorCode: zod.number(),
|
|
3642
|
+
message: zod.string()
|
|
3643
|
+
}).strict();
|
|
2033
3644
|
const listTestExecutionLinksPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
2034
3645
|
const ListTestExecutionLinksParams = zod.object({
|
|
2035
3646
|
testExecutionIdOrKey: zod.string().regex(listTestExecutionLinksPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -2058,6 +3669,18 @@ zod.object({
|
|
|
2058
3669
|
errorCode: zod.number(),
|
|
2059
3670
|
message: zod.string()
|
|
2060
3671
|
}).strict();
|
|
3672
|
+
zod.object({
|
|
3673
|
+
errorCode: zod.number(),
|
|
3674
|
+
message: zod.string()
|
|
3675
|
+
}).strict();
|
|
3676
|
+
zod.object({
|
|
3677
|
+
errorCode: zod.number(),
|
|
3678
|
+
message: zod.string()
|
|
3679
|
+
}).strict();
|
|
3680
|
+
zod.object({
|
|
3681
|
+
errorCode: zod.number(),
|
|
3682
|
+
message: zod.string()
|
|
3683
|
+
}).strict();
|
|
2061
3684
|
const createTestExecutionIssueLinkPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
2062
3685
|
const CreateTestExecutionIssueLinkParams = zod.object({
|
|
2063
3686
|
testExecutionIdOrKey: zod.string().regex(createTestExecutionIssueLinkPathTestExecutionIdOrKeyRegExp).describe(
|
|
@@ -2071,6 +3694,177 @@ zod.object({
|
|
|
2071
3694
|
errorCode: zod.number(),
|
|
2072
3695
|
message: zod.string()
|
|
2073
3696
|
}).strict();
|
|
3697
|
+
zod.object({
|
|
3698
|
+
errorCode: zod.number(),
|
|
3699
|
+
message: zod.string()
|
|
3700
|
+
}).strict();
|
|
3701
|
+
zod.object({
|
|
3702
|
+
errorCode: zod.number(),
|
|
3703
|
+
message: zod.string()
|
|
3704
|
+
}).strict();
|
|
3705
|
+
zod.object({
|
|
3706
|
+
errorCode: zod.number(),
|
|
3707
|
+
message: zod.string()
|
|
3708
|
+
}).strict();
|
|
3709
|
+
const getTestExecutionTestStepAttachmentsReferencePathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
3710
|
+
const getTestExecutionTestStepAttachmentsReferencePathTestStepIdRegExp = /([0-9]+)/;
|
|
3711
|
+
zod.object({
|
|
3712
|
+
testExecutionIdOrKey: zod.string().regex(
|
|
3713
|
+
getTestExecutionTestStepAttachmentsReferencePathTestExecutionIdOrKeyRegExp
|
|
3714
|
+
).describe(
|
|
3715
|
+
"The ID or key of the test execution. Test execution keys are of the format [A-Z]+-E[0-9]+"
|
|
3716
|
+
),
|
|
3717
|
+
testStepId: zod.string().regex(getTestExecutionTestStepAttachmentsReferencePathTestStepIdRegExp).describe(
|
|
3718
|
+
"The ID of the test case step. Test step IDs are numeric, of the format [0-9]+"
|
|
3719
|
+
)
|
|
3720
|
+
}).strict();
|
|
3721
|
+
zod.object({
|
|
3722
|
+
attachments: zod.array(
|
|
3723
|
+
zod.object({
|
|
3724
|
+
id: zod.number().optional().describe("Database ID of the attachment."),
|
|
3725
|
+
name: zod.string().optional().describe("File name of the attachment.")
|
|
3726
|
+
}).strict()
|
|
3727
|
+
).optional()
|
|
3728
|
+
}).strict();
|
|
3729
|
+
zod.object({
|
|
3730
|
+
errorCode: zod.number(),
|
|
3731
|
+
message: zod.string()
|
|
3732
|
+
}).strict();
|
|
3733
|
+
zod.object({
|
|
3734
|
+
errorCode: zod.number(),
|
|
3735
|
+
message: zod.string()
|
|
3736
|
+
}).strict();
|
|
3737
|
+
zod.object({
|
|
3738
|
+
errorCode: zod.number(),
|
|
3739
|
+
message: zod.string()
|
|
3740
|
+
}).strict();
|
|
3741
|
+
zod.object({
|
|
3742
|
+
errorCode: zod.number(),
|
|
3743
|
+
message: zod.string()
|
|
3744
|
+
}).strict();
|
|
3745
|
+
const getTestExecutionAttachmentsReferencePathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
3746
|
+
zod.object({
|
|
3747
|
+
testExecutionIdOrKey: zod.string().regex(getTestExecutionAttachmentsReferencePathTestExecutionIdOrKeyRegExp).describe(
|
|
3748
|
+
"The ID or key of the test execution. Test execution keys are of the format [A-Z]+-E[0-9]+"
|
|
3749
|
+
)
|
|
3750
|
+
}).strict();
|
|
3751
|
+
zod.object({
|
|
3752
|
+
attachments: zod.array(
|
|
3753
|
+
zod.object({
|
|
3754
|
+
id: zod.number().optional().describe("Database ID of the attachment."),
|
|
3755
|
+
name: zod.string().optional().describe("File name of the attachment.")
|
|
3756
|
+
}).strict()
|
|
3757
|
+
).optional()
|
|
3758
|
+
}).strict();
|
|
3759
|
+
zod.object({
|
|
3760
|
+
errorCode: zod.number(),
|
|
3761
|
+
message: zod.string()
|
|
3762
|
+
}).strict();
|
|
3763
|
+
zod.object({
|
|
3764
|
+
errorCode: zod.number(),
|
|
3765
|
+
message: zod.string()
|
|
3766
|
+
}).strict();
|
|
3767
|
+
zod.object({
|
|
3768
|
+
errorCode: zod.number(),
|
|
3769
|
+
message: zod.string()
|
|
3770
|
+
}).strict();
|
|
3771
|
+
zod.object({
|
|
3772
|
+
errorCode: zod.number(),
|
|
3773
|
+
message: zod.string()
|
|
3774
|
+
}).strict();
|
|
3775
|
+
const uploadTestExecutionAttachmentPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
3776
|
+
const uploadTestExecutionAttachmentPathFileNameMax = 255;
|
|
3777
|
+
zod.object({
|
|
3778
|
+
testExecutionIdOrKey: zod.string().regex(uploadTestExecutionAttachmentPathTestExecutionIdOrKeyRegExp).describe(
|
|
3779
|
+
"The ID or key of the test execution. Test execution keys are of the format [A-Z]+-E[0-9]+"
|
|
3780
|
+
),
|
|
3781
|
+
fileName: zod.string().min(1).max(uploadTestExecutionAttachmentPathFileNameMax).describe(
|
|
3782
|
+
"The name of the file being uploaded, including its extension (for example, `screenshot.png`).\nThis is used as the attachment's display name. URL-encode any special characters and keep\nthe name to 255 characters or fewer.\n"
|
|
3783
|
+
)
|
|
3784
|
+
}).strict();
|
|
3785
|
+
zod.object({
|
|
3786
|
+
errorCode: zod.number(),
|
|
3787
|
+
message: zod.string()
|
|
3788
|
+
}).strict();
|
|
3789
|
+
zod.object({
|
|
3790
|
+
errorCode: zod.number(),
|
|
3791
|
+
message: zod.string()
|
|
3792
|
+
}).strict();
|
|
3793
|
+
zod.object({
|
|
3794
|
+
errorCode: zod.number(),
|
|
3795
|
+
message: zod.string()
|
|
3796
|
+
}).strict();
|
|
3797
|
+
zod.object({
|
|
3798
|
+
errorCode: zod.number(),
|
|
3799
|
+
message: zod.string()
|
|
3800
|
+
}).strict();
|
|
3801
|
+
zod.object({
|
|
3802
|
+
errorCode: zod.number(),
|
|
3803
|
+
message: zod.string()
|
|
3804
|
+
}).strict();
|
|
3805
|
+
zod.object({
|
|
3806
|
+
errorCode: zod.number(),
|
|
3807
|
+
message: zod.string()
|
|
3808
|
+
}).strict();
|
|
3809
|
+
zod.object({
|
|
3810
|
+
errorCode: zod.number(),
|
|
3811
|
+
message: zod.string()
|
|
3812
|
+
}).strict();
|
|
3813
|
+
const getTestExecutionStepAttachmentPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
3814
|
+
zod.object({
|
|
3815
|
+
testExecutionIdOrKey: zod.string().regex(getTestExecutionStepAttachmentPathTestExecutionIdOrKeyRegExp).describe(
|
|
3816
|
+
"The ID or key of the test execution. Test execution keys are of the format [A-Z]+-E[0-9]+"
|
|
3817
|
+
),
|
|
3818
|
+
testExecutionStepId: zod.number().min(1).describe("The ID of the step within the test execution."),
|
|
3819
|
+
attachmentId: zod.number().min(1).describe("The numeric ID of the attachment.")
|
|
3820
|
+
}).strict();
|
|
3821
|
+
zod.object({
|
|
3822
|
+
errorCode: zod.number(),
|
|
3823
|
+
message: zod.string()
|
|
3824
|
+
}).strict();
|
|
3825
|
+
zod.object({
|
|
3826
|
+
errorCode: zod.number(),
|
|
3827
|
+
message: zod.string()
|
|
3828
|
+
}).strict();
|
|
3829
|
+
zod.object({
|
|
3830
|
+
errorCode: zod.number(),
|
|
3831
|
+
message: zod.string()
|
|
3832
|
+
}).strict();
|
|
3833
|
+
zod.object({
|
|
3834
|
+
errorCode: zod.number(),
|
|
3835
|
+
message: zod.string()
|
|
3836
|
+
}).strict();
|
|
3837
|
+
zod.object({
|
|
3838
|
+
errorCode: zod.number(),
|
|
3839
|
+
message: zod.string()
|
|
3840
|
+
}).strict();
|
|
3841
|
+
const getTestExecutionAttachmentPathTestExecutionIdOrKeyRegExp = /([0-9]+)|(.+-E[0-9]+)/;
|
|
3842
|
+
zod.object({
|
|
3843
|
+
testExecutionIdOrKey: zod.string().regex(getTestExecutionAttachmentPathTestExecutionIdOrKeyRegExp).describe(
|
|
3844
|
+
"The ID or key of the test execution. Test execution keys are of the format [A-Z]+-E[0-9]+"
|
|
3845
|
+
),
|
|
3846
|
+
attachmentId: zod.number().min(1).describe("The numeric ID of the attachment.")
|
|
3847
|
+
}).strict();
|
|
3848
|
+
zod.object({
|
|
3849
|
+
errorCode: zod.number(),
|
|
3850
|
+
message: zod.string()
|
|
3851
|
+
}).strict();
|
|
3852
|
+
zod.object({
|
|
3853
|
+
errorCode: zod.number(),
|
|
3854
|
+
message: zod.string()
|
|
3855
|
+
}).strict();
|
|
3856
|
+
zod.object({
|
|
3857
|
+
errorCode: zod.number(),
|
|
3858
|
+
message: zod.string()
|
|
3859
|
+
}).strict();
|
|
3860
|
+
zod.object({
|
|
3861
|
+
errorCode: zod.number(),
|
|
3862
|
+
message: zod.string()
|
|
3863
|
+
}).strict();
|
|
3864
|
+
zod.object({
|
|
3865
|
+
errorCode: zod.number(),
|
|
3866
|
+
message: zod.string()
|
|
3867
|
+
}).strict();
|
|
2074
3868
|
const listProjectsQueryMaxResultsDefault = 10;
|
|
2075
3869
|
const listProjectsQueryStartAtDefault = 0;
|
|
2076
3870
|
const listProjectsQueryStartAtMin = 0;
|
|
@@ -2114,6 +3908,14 @@ zod.object({
|
|
|
2114
3908
|
errorCode: zod.number(),
|
|
2115
3909
|
message: zod.string()
|
|
2116
3910
|
}).strict();
|
|
3911
|
+
zod.object({
|
|
3912
|
+
errorCode: zod.number(),
|
|
3913
|
+
message: zod.string()
|
|
3914
|
+
}).strict();
|
|
3915
|
+
zod.object({
|
|
3916
|
+
errorCode: zod.number(),
|
|
3917
|
+
message: zod.string()
|
|
3918
|
+
}).strict();
|
|
2117
3919
|
const getProjectPathProjectIdOrKeyRegExp = /([0-9]+)|([A-Z][A-Z_0-9]+)/;
|
|
2118
3920
|
const GetProjectParams = zod.object({
|
|
2119
3921
|
projectIdOrKey: zod.string().regex(getProjectPathProjectIdOrKeyRegExp).describe("The Zephyr project ID or Jira project key")
|
|
@@ -2128,6 +3930,18 @@ zod.object({
|
|
|
2128
3930
|
errorCode: zod.number(),
|
|
2129
3931
|
message: zod.string()
|
|
2130
3932
|
}).strict();
|
|
3933
|
+
zod.object({
|
|
3934
|
+
errorCode: zod.number(),
|
|
3935
|
+
message: zod.string()
|
|
3936
|
+
}).strict();
|
|
3937
|
+
zod.object({
|
|
3938
|
+
errorCode: zod.number(),
|
|
3939
|
+
message: zod.string()
|
|
3940
|
+
}).strict();
|
|
3941
|
+
zod.object({
|
|
3942
|
+
errorCode: zod.number(),
|
|
3943
|
+
message: zod.string()
|
|
3944
|
+
}).strict();
|
|
2131
3945
|
const listFoldersQueryMaxResultsDefault = 10;
|
|
2132
3946
|
const listFoldersQueryStartAtDefault = 0;
|
|
2133
3947
|
const listFoldersQueryStartAtMin = 0;
|
|
@@ -2186,6 +4000,14 @@ zod.object({
|
|
|
2186
4000
|
errorCode: zod.number(),
|
|
2187
4001
|
message: zod.string()
|
|
2188
4002
|
}).strict();
|
|
4003
|
+
zod.object({
|
|
4004
|
+
errorCode: zod.number(),
|
|
4005
|
+
message: zod.string()
|
|
4006
|
+
}).strict();
|
|
4007
|
+
zod.object({
|
|
4008
|
+
errorCode: zod.number(),
|
|
4009
|
+
message: zod.string()
|
|
4010
|
+
}).strict();
|
|
2189
4011
|
const createFolderBodyNameMax = 255;
|
|
2190
4012
|
const createFolderBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2191
4013
|
const CreateFolderBody = zod.object({
|
|
@@ -2206,6 +4028,14 @@ zod.object({
|
|
|
2206
4028
|
errorCode: zod.number(),
|
|
2207
4029
|
message: zod.string()
|
|
2208
4030
|
}).strict();
|
|
4031
|
+
zod.object({
|
|
4032
|
+
errorCode: zod.number(),
|
|
4033
|
+
message: zod.string()
|
|
4034
|
+
}).strict();
|
|
4035
|
+
zod.object({
|
|
4036
|
+
errorCode: zod.number(),
|
|
4037
|
+
message: zod.string()
|
|
4038
|
+
}).strict();
|
|
2209
4039
|
zod.object({
|
|
2210
4040
|
folderId: zod.number().min(1).describe("Folder ID")
|
|
2211
4041
|
}).strict();
|
|
@@ -2227,6 +4057,18 @@ zod.object({
|
|
|
2227
4057
|
errorCode: zod.number(),
|
|
2228
4058
|
message: zod.string()
|
|
2229
4059
|
}).strict();
|
|
4060
|
+
zod.object({
|
|
4061
|
+
errorCode: zod.number(),
|
|
4062
|
+
message: zod.string()
|
|
4063
|
+
}).strict();
|
|
4064
|
+
zod.object({
|
|
4065
|
+
errorCode: zod.number(),
|
|
4066
|
+
message: zod.string()
|
|
4067
|
+
}).strict();
|
|
4068
|
+
zod.object({
|
|
4069
|
+
errorCode: zod.number(),
|
|
4070
|
+
message: zod.string()
|
|
4071
|
+
}).strict();
|
|
2230
4072
|
const listPrioritiesQueryMaxResultsDefault = 10;
|
|
2231
4073
|
const listPrioritiesQueryStartAtDefault = 0;
|
|
2232
4074
|
const listPrioritiesQueryStartAtMin = 0;
|
|
@@ -2283,6 +4125,14 @@ zod.object({
|
|
|
2283
4125
|
errorCode: zod.number(),
|
|
2284
4126
|
message: zod.string()
|
|
2285
4127
|
}).strict();
|
|
4128
|
+
zod.object({
|
|
4129
|
+
errorCode: zod.number(),
|
|
4130
|
+
message: zod.string()
|
|
4131
|
+
}).strict();
|
|
4132
|
+
zod.object({
|
|
4133
|
+
errorCode: zod.number(),
|
|
4134
|
+
message: zod.string()
|
|
4135
|
+
}).strict();
|
|
2286
4136
|
const createPriorityBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2287
4137
|
const createPriorityBodyNameMax = 255;
|
|
2288
4138
|
const createPriorityBodyDescriptionMax = 255;
|
|
@@ -2301,6 +4151,14 @@ zod.object({
|
|
|
2301
4151
|
errorCode: zod.number(),
|
|
2302
4152
|
message: zod.string()
|
|
2303
4153
|
}).strict();
|
|
4154
|
+
zod.object({
|
|
4155
|
+
errorCode: zod.number(),
|
|
4156
|
+
message: zod.string()
|
|
4157
|
+
}).strict();
|
|
4158
|
+
zod.object({
|
|
4159
|
+
errorCode: zod.number(),
|
|
4160
|
+
message: zod.string()
|
|
4161
|
+
}).strict();
|
|
2304
4162
|
zod.object({
|
|
2305
4163
|
priorityId: zod.number().min(1)
|
|
2306
4164
|
}).strict();
|
|
@@ -2329,6 +4187,14 @@ zod.object({
|
|
|
2329
4187
|
errorCode: zod.number(),
|
|
2330
4188
|
message: zod.string()
|
|
2331
4189
|
}).strict();
|
|
4190
|
+
zod.object({
|
|
4191
|
+
errorCode: zod.number(),
|
|
4192
|
+
message: zod.string()
|
|
4193
|
+
}).strict();
|
|
4194
|
+
zod.object({
|
|
4195
|
+
errorCode: zod.number(),
|
|
4196
|
+
message: zod.string()
|
|
4197
|
+
}).strict();
|
|
2332
4198
|
zod.object({
|
|
2333
4199
|
priorityId: zod.number().min(1)
|
|
2334
4200
|
}).strict();
|
|
@@ -2352,6 +4218,18 @@ zod.object({
|
|
|
2352
4218
|
errorCode: zod.number(),
|
|
2353
4219
|
message: zod.string()
|
|
2354
4220
|
}).strict();
|
|
4221
|
+
zod.object({
|
|
4222
|
+
errorCode: zod.number(),
|
|
4223
|
+
message: zod.string()
|
|
4224
|
+
}).strict();
|
|
4225
|
+
zod.object({
|
|
4226
|
+
errorCode: zod.number(),
|
|
4227
|
+
message: zod.string()
|
|
4228
|
+
}).strict();
|
|
4229
|
+
zod.object({
|
|
4230
|
+
errorCode: zod.number(),
|
|
4231
|
+
message: zod.string()
|
|
4232
|
+
}).strict();
|
|
2355
4233
|
const listStatusesQueryMaxResultsDefault = 10;
|
|
2356
4234
|
const listStatusesQueryStartAtDefault = 0;
|
|
2357
4235
|
const listStatusesQueryStartAtMin = 0;
|
|
@@ -2412,6 +4290,14 @@ zod.object({
|
|
|
2412
4290
|
errorCode: zod.number(),
|
|
2413
4291
|
message: zod.string()
|
|
2414
4292
|
}).strict();
|
|
4293
|
+
zod.object({
|
|
4294
|
+
errorCode: zod.number(),
|
|
4295
|
+
message: zod.string()
|
|
4296
|
+
}).strict();
|
|
4297
|
+
zod.object({
|
|
4298
|
+
errorCode: zod.number(),
|
|
4299
|
+
message: zod.string()
|
|
4300
|
+
}).strict();
|
|
2415
4301
|
const createStatusBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2416
4302
|
const createStatusBodyNameMax = 255;
|
|
2417
4303
|
const createStatusBodyDescriptionMax = 255;
|
|
@@ -2431,6 +4317,14 @@ zod.object({
|
|
|
2431
4317
|
errorCode: zod.number(),
|
|
2432
4318
|
message: zod.string()
|
|
2433
4319
|
}).strict();
|
|
4320
|
+
zod.object({
|
|
4321
|
+
errorCode: zod.number(),
|
|
4322
|
+
message: zod.string()
|
|
4323
|
+
}).strict();
|
|
4324
|
+
zod.object({
|
|
4325
|
+
errorCode: zod.number(),
|
|
4326
|
+
message: zod.string()
|
|
4327
|
+
}).strict();
|
|
2434
4328
|
zod.object({
|
|
2435
4329
|
statusId: zod.number().min(1)
|
|
2436
4330
|
}).strict();
|
|
@@ -2462,6 +4356,14 @@ zod.object({
|
|
|
2462
4356
|
errorCode: zod.number(),
|
|
2463
4357
|
message: zod.string()
|
|
2464
4358
|
}).strict();
|
|
4359
|
+
zod.object({
|
|
4360
|
+
errorCode: zod.number(),
|
|
4361
|
+
message: zod.string()
|
|
4362
|
+
}).strict();
|
|
4363
|
+
zod.object({
|
|
4364
|
+
errorCode: zod.number(),
|
|
4365
|
+
message: zod.string()
|
|
4366
|
+
}).strict();
|
|
2465
4367
|
zod.object({
|
|
2466
4368
|
statusId: zod.number().min(1)
|
|
2467
4369
|
}).strict();
|
|
@@ -2486,6 +4388,18 @@ zod.object({
|
|
|
2486
4388
|
errorCode: zod.number(),
|
|
2487
4389
|
message: zod.string()
|
|
2488
4390
|
}).strict();
|
|
4391
|
+
zod.object({
|
|
4392
|
+
errorCode: zod.number(),
|
|
4393
|
+
message: zod.string()
|
|
4394
|
+
}).strict();
|
|
4395
|
+
zod.object({
|
|
4396
|
+
errorCode: zod.number(),
|
|
4397
|
+
message: zod.string()
|
|
4398
|
+
}).strict();
|
|
4399
|
+
zod.object({
|
|
4400
|
+
errorCode: zod.number(),
|
|
4401
|
+
message: zod.string()
|
|
4402
|
+
}).strict();
|
|
2489
4403
|
const listEnvironmentsQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2490
4404
|
const listEnvironmentsQueryMaxResultsDefault = 10;
|
|
2491
4405
|
const listEnvironmentsQueryStartAtDefault = 0;
|
|
@@ -2542,6 +4456,14 @@ zod.object({
|
|
|
2542
4456
|
errorCode: zod.number(),
|
|
2543
4457
|
message: zod.string()
|
|
2544
4458
|
}).strict();
|
|
4459
|
+
zod.object({
|
|
4460
|
+
errorCode: zod.number(),
|
|
4461
|
+
message: zod.string()
|
|
4462
|
+
}).strict();
|
|
4463
|
+
zod.object({
|
|
4464
|
+
errorCode: zod.number(),
|
|
4465
|
+
message: zod.string()
|
|
4466
|
+
}).strict();
|
|
2545
4467
|
const createEnvironmentBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2546
4468
|
const createEnvironmentBodyNameMax = 255;
|
|
2547
4469
|
const createEnvironmentBodyDescriptionMax = 255;
|
|
@@ -2576,6 +4498,14 @@ zod.object({
|
|
|
2576
4498
|
errorCode: zod.number(),
|
|
2577
4499
|
message: zod.string()
|
|
2578
4500
|
}).strict();
|
|
4501
|
+
zod.object({
|
|
4502
|
+
errorCode: zod.number(),
|
|
4503
|
+
message: zod.string()
|
|
4504
|
+
}).strict();
|
|
4505
|
+
zod.object({
|
|
4506
|
+
errorCode: zod.number(),
|
|
4507
|
+
message: zod.string()
|
|
4508
|
+
}).strict();
|
|
2579
4509
|
zod.object({
|
|
2580
4510
|
environmentId: zod.number().min(1)
|
|
2581
4511
|
}).strict();
|
|
@@ -2602,6 +4532,14 @@ zod.object({
|
|
|
2602
4532
|
errorCode: zod.number(),
|
|
2603
4533
|
message: zod.string()
|
|
2604
4534
|
}).strict();
|
|
4535
|
+
zod.object({
|
|
4536
|
+
errorCode: zod.number(),
|
|
4537
|
+
message: zod.string()
|
|
4538
|
+
}).strict();
|
|
4539
|
+
zod.object({
|
|
4540
|
+
errorCode: zod.number(),
|
|
4541
|
+
message: zod.string()
|
|
4542
|
+
}).strict();
|
|
2605
4543
|
zod.object({
|
|
2606
4544
|
environmentId: zod.number().min(1)
|
|
2607
4545
|
}).strict();
|
|
@@ -2644,6 +4582,18 @@ zod.object({
|
|
|
2644
4582
|
errorCode: zod.number(),
|
|
2645
4583
|
message: zod.string()
|
|
2646
4584
|
}).strict();
|
|
4585
|
+
zod.object({
|
|
4586
|
+
errorCode: zod.number(),
|
|
4587
|
+
message: zod.string()
|
|
4588
|
+
}).strict();
|
|
4589
|
+
zod.object({
|
|
4590
|
+
errorCode: zod.number(),
|
|
4591
|
+
message: zod.string()
|
|
4592
|
+
}).strict();
|
|
4593
|
+
zod.object({
|
|
4594
|
+
errorCode: zod.number(),
|
|
4595
|
+
message: zod.string()
|
|
4596
|
+
}).strict();
|
|
2647
4597
|
zod.object({
|
|
2648
4598
|
linkId: zod.number().min(1)
|
|
2649
4599
|
}).strict();
|
|
@@ -2651,6 +4601,18 @@ zod.object({
|
|
|
2651
4601
|
errorCode: zod.number(),
|
|
2652
4602
|
message: zod.string()
|
|
2653
4603
|
}).strict();
|
|
4604
|
+
zod.object({
|
|
4605
|
+
errorCode: zod.number(),
|
|
4606
|
+
message: zod.string()
|
|
4607
|
+
}).strict();
|
|
4608
|
+
zod.object({
|
|
4609
|
+
errorCode: zod.number(),
|
|
4610
|
+
message: zod.string()
|
|
4611
|
+
}).strict();
|
|
4612
|
+
zod.object({
|
|
4613
|
+
errorCode: zod.number(),
|
|
4614
|
+
message: zod.string()
|
|
4615
|
+
}).strict();
|
|
2654
4616
|
const getIssueLinkTestCasesPathIssueKeyRegExp = /.+-[0-9]+/;
|
|
2655
4617
|
const GetIssueLinkTestCasesParams = zod.object({
|
|
2656
4618
|
issueKey: zod.string().regex(getIssueLinkTestCasesPathIssueKeyRegExp).describe("The key of the Jira issue")
|
|
@@ -2667,6 +4629,18 @@ zod.object({
|
|
|
2667
4629
|
errorCode: zod.number(),
|
|
2668
4630
|
message: zod.string()
|
|
2669
4631
|
}).strict();
|
|
4632
|
+
zod.object({
|
|
4633
|
+
errorCode: zod.number(),
|
|
4634
|
+
message: zod.string()
|
|
4635
|
+
}).strict();
|
|
4636
|
+
zod.object({
|
|
4637
|
+
errorCode: zod.number(),
|
|
4638
|
+
message: zod.string()
|
|
4639
|
+
}).strict();
|
|
4640
|
+
zod.object({
|
|
4641
|
+
errorCode: zod.number(),
|
|
4642
|
+
message: zod.string()
|
|
4643
|
+
}).strict();
|
|
2670
4644
|
const getIssueLinkTestCyclesPathIssueKeyRegExp = /.+-[0-9]+/;
|
|
2671
4645
|
const GetIssueLinkTestCyclesParams = zod.object({
|
|
2672
4646
|
issueKey: zod.string().regex(getIssueLinkTestCyclesPathIssueKeyRegExp).describe("The key of the Jira issue")
|
|
@@ -2682,6 +4656,18 @@ zod.object({
|
|
|
2682
4656
|
errorCode: zod.number(),
|
|
2683
4657
|
message: zod.string()
|
|
2684
4658
|
}).strict();
|
|
4659
|
+
zod.object({
|
|
4660
|
+
errorCode: zod.number(),
|
|
4661
|
+
message: zod.string()
|
|
4662
|
+
}).strict();
|
|
4663
|
+
zod.object({
|
|
4664
|
+
errorCode: zod.number(),
|
|
4665
|
+
message: zod.string()
|
|
4666
|
+
}).strict();
|
|
4667
|
+
zod.object({
|
|
4668
|
+
errorCode: zod.number(),
|
|
4669
|
+
message: zod.string()
|
|
4670
|
+
}).strict();
|
|
2685
4671
|
const getIssueLinkTestPlansPathIssueKeyRegExp = /.+-[0-9]+/;
|
|
2686
4672
|
zod.object({
|
|
2687
4673
|
issueKey: zod.string().regex(getIssueLinkTestPlansPathIssueKeyRegExp).describe("The key of the Jira issue")
|
|
@@ -2697,6 +4683,18 @@ zod.object({
|
|
|
2697
4683
|
errorCode: zod.number(),
|
|
2698
4684
|
message: zod.string()
|
|
2699
4685
|
}).strict();
|
|
4686
|
+
zod.object({
|
|
4687
|
+
errorCode: zod.number(),
|
|
4688
|
+
message: zod.string()
|
|
4689
|
+
}).strict();
|
|
4690
|
+
zod.object({
|
|
4691
|
+
errorCode: zod.number(),
|
|
4692
|
+
message: zod.string()
|
|
4693
|
+
}).strict();
|
|
4694
|
+
zod.object({
|
|
4695
|
+
errorCode: zod.number(),
|
|
4696
|
+
message: zod.string()
|
|
4697
|
+
}).strict();
|
|
2700
4698
|
const getIssueLinkTestExecutionsPathIssueKeyRegExp = /.+-[0-9]+/;
|
|
2701
4699
|
const GetIssueLinkTestExecutionsParams = zod.object({
|
|
2702
4700
|
issueKey: zod.string().regex(getIssueLinkTestExecutionsPathIssueKeyRegExp).describe("The key of the Jira issue")
|
|
@@ -2712,6 +4710,18 @@ zod.object({
|
|
|
2712
4710
|
errorCode: zod.number(),
|
|
2713
4711
|
message: zod.string()
|
|
2714
4712
|
}).strict();
|
|
4713
|
+
zod.object({
|
|
4714
|
+
errorCode: zod.number(),
|
|
4715
|
+
message: zod.string()
|
|
4716
|
+
}).strict();
|
|
4717
|
+
zod.object({
|
|
4718
|
+
errorCode: zod.number(),
|
|
4719
|
+
message: zod.string()
|
|
4720
|
+
}).strict();
|
|
4721
|
+
zod.object({
|
|
4722
|
+
errorCode: zod.number(),
|
|
4723
|
+
message: zod.string()
|
|
4724
|
+
}).strict();
|
|
2715
4725
|
const createCustomExecutionsQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2716
4726
|
const createCustomExecutionsQueryAutoCreateTestCasesDefault = false;
|
|
2717
4727
|
zod.object({
|
|
@@ -2753,6 +4763,14 @@ zod.object({
|
|
|
2753
4763
|
errorCode: zod.number(),
|
|
2754
4764
|
message: zod.string()
|
|
2755
4765
|
}).strict();
|
|
4766
|
+
zod.object({
|
|
4767
|
+
errorCode: zod.number(),
|
|
4768
|
+
message: zod.string()
|
|
4769
|
+
}).strict();
|
|
4770
|
+
zod.object({
|
|
4771
|
+
errorCode: zod.number(),
|
|
4772
|
+
message: zod.string()
|
|
4773
|
+
}).strict();
|
|
2756
4774
|
const createCucumberExecutionsQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2757
4775
|
const createCucumberExecutionsQueryAutoCreateTestCasesDefault = false;
|
|
2758
4776
|
zod.object({
|
|
@@ -2794,6 +4812,14 @@ zod.object({
|
|
|
2794
4812
|
errorCode: zod.number(),
|
|
2795
4813
|
message: zod.string()
|
|
2796
4814
|
}).strict();
|
|
4815
|
+
zod.object({
|
|
4816
|
+
errorCode: zod.number(),
|
|
4817
|
+
message: zod.string()
|
|
4818
|
+
}).strict();
|
|
4819
|
+
zod.object({
|
|
4820
|
+
errorCode: zod.number(),
|
|
4821
|
+
message: zod.string()
|
|
4822
|
+
}).strict();
|
|
2797
4823
|
const createJUnitExecutionsQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2798
4824
|
const createJUnitExecutionsQueryAutoCreateTestCasesDefault = false;
|
|
2799
4825
|
zod.object({
|
|
@@ -2835,6 +4861,14 @@ zod.object({
|
|
|
2835
4861
|
errorCode: zod.number(),
|
|
2836
4862
|
message: zod.string()
|
|
2837
4863
|
}).strict();
|
|
4864
|
+
zod.object({
|
|
4865
|
+
errorCode: zod.number(),
|
|
4866
|
+
message: zod.string()
|
|
4867
|
+
}).strict();
|
|
4868
|
+
zod.object({
|
|
4869
|
+
errorCode: zod.number(),
|
|
4870
|
+
message: zod.string()
|
|
4871
|
+
}).strict();
|
|
2838
4872
|
const retrieveBDDTestCasesQueryProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
|
|
2839
4873
|
zod.object({
|
|
2840
4874
|
projectKey: zod.string().regex(retrieveBDDTestCasesQueryProjectKeyRegExp).describe("Jira project key filter")
|
|
@@ -2850,6 +4884,22 @@ zod.object({
|
|
|
2850
4884
|
errorCode: zod.number(),
|
|
2851
4885
|
message: zod.string()
|
|
2852
4886
|
}).strict();
|
|
4887
|
+
zod.object({
|
|
4888
|
+
errorCode: zod.number(),
|
|
4889
|
+
message: zod.string()
|
|
4890
|
+
}).strict();
|
|
4891
|
+
zod.object({
|
|
4892
|
+
errorCode: zod.number(),
|
|
4893
|
+
message: zod.string()
|
|
4894
|
+
}).strict();
|
|
4895
|
+
zod.object({
|
|
4896
|
+
errorCode: zod.number(),
|
|
4897
|
+
message: zod.string()
|
|
4898
|
+
}).strict();
|
|
4899
|
+
zod.object({
|
|
4900
|
+
errorCode: zod.number(),
|
|
4901
|
+
message: zod.string()
|
|
4902
|
+
}).strict();
|
|
2853
4903
|
export {
|
|
2854
4904
|
CreateFolder201Response,
|
|
2855
4905
|
CreateFolderBody,
|
|
@@ -2970,6 +5020,8 @@ export {
|
|
|
2970
5020
|
createTestCaseBodyStatusNameMax,
|
|
2971
5021
|
createTestCaseIssueLinkPathTestCaseKeyRegExp,
|
|
2972
5022
|
createTestCaseTestScriptPathTestCaseKeyRegExp,
|
|
5023
|
+
createTestCaseTestStepAttachmentPathFileNameMax,
|
|
5024
|
+
createTestCaseTestStepAttachmentPathTestCaseIdOrKeyRegExp,
|
|
2973
5025
|
createTestCaseTestStepsBodyItemsItemTestCaseTwoTestCaseKeyRegExp,
|
|
2974
5026
|
createTestCaseTestStepsPathTestCaseKeyRegExp,
|
|
2975
5027
|
createTestCaseWebLinkPathTestCaseKeyRegExp,
|
|
@@ -2989,6 +5041,10 @@ export {
|
|
|
2989
5041
|
createTestExecutionBodyTestCycleKeyRegExp,
|
|
2990
5042
|
createTestExecutionBodyTestScriptResultsItemStatusNameMax,
|
|
2991
5043
|
createTestExecutionIssueLinkPathTestExecutionIdOrKeyRegExp,
|
|
5044
|
+
createTestExecutionTestStepAttachmentPathFileNameMax,
|
|
5045
|
+
createTestExecutionTestStepAttachmentPathTestExecutionIdOrKeyRegExp,
|
|
5046
|
+
createTestPlanAttachmentPathFileNameMax,
|
|
5047
|
+
createTestPlanAttachmentPathTestPlanIdOrKeyRegExp,
|
|
2992
5048
|
createTestPlanBodyLabelsMax,
|
|
2993
5049
|
createTestPlanBodyNameMax,
|
|
2994
5050
|
createTestPlanBodyNameRegExp,
|
|
@@ -3027,9 +5083,14 @@ export {
|
|
|
3027
5083
|
getTestCase200ResponseNameMax,
|
|
3028
5084
|
getTestCase200ResponseNameRegExp,
|
|
3029
5085
|
getTestCase200ResponseOwnerAccountIdRegExp,
|
|
5086
|
+
getTestCaseAttachmentPathTestCaseKeyRegExp,
|
|
5087
|
+
getTestCaseAttachmentsReferencePathTestCaseIdOrKeyRegExp,
|
|
3030
5088
|
getTestCaseLinksPathTestCaseKeyRegExp,
|
|
3031
5089
|
getTestCasePathTestCaseKeyRegExp,
|
|
5090
|
+
getTestCaseStepAttachmentPathTestCaseIdOrKeyRegExp,
|
|
3032
5091
|
getTestCaseTestScriptPathTestCaseKeyRegExp,
|
|
5092
|
+
getTestCaseTestStepAttachmentsReferencePathTestCaseIdOrKeyRegExp,
|
|
5093
|
+
getTestCaseTestStepAttachmentsReferencePathTestStepIdRegExp,
|
|
3033
5094
|
getTestCaseTestSteps200ResponseOneStartAtMin,
|
|
3034
5095
|
getTestCaseTestSteps200ResponseOneTotalMin,
|
|
3035
5096
|
getTestCaseTestSteps200ResponseTwoValuesItemTestCaseOneTwoTestCaseKeyRegExp,
|
|
@@ -3048,6 +5109,8 @@ export {
|
|
|
3048
5109
|
getTestCycle200ResponseKeyRegExp,
|
|
3049
5110
|
getTestCycle200ResponseNameRegExp,
|
|
3050
5111
|
getTestCycle200ResponseOwnerAccountIdRegExp,
|
|
5112
|
+
getTestCycleAttachmentPathTestCycleIdOrKeyRegExp,
|
|
5113
|
+
getTestCycleAttachmentsPathTestCycleIdOrKeyRegExp,
|
|
3051
5114
|
getTestCycleLinksPathTestCycleIdOrKeyRegExp,
|
|
3052
5115
|
getTestCyclePathTestCycleIdOrKeyRegExp,
|
|
3053
5116
|
getTestExecution200ResponseAssignedToIdRegExp,
|
|
@@ -3055,8 +5118,13 @@ export {
|
|
|
3055
5118
|
getTestExecution200ResponseExecutedByIdRegExp,
|
|
3056
5119
|
getTestExecution200ResponseExecutionTimeMin,
|
|
3057
5120
|
getTestExecution200ResponseKeyRegExp,
|
|
5121
|
+
getTestExecutionAttachmentPathTestExecutionIdOrKeyRegExp,
|
|
5122
|
+
getTestExecutionAttachmentsReferencePathTestExecutionIdOrKeyRegExp,
|
|
3058
5123
|
getTestExecutionPathTestExecutionIdOrKeyRegExp,
|
|
3059
5124
|
getTestExecutionQueryIncludeStepLinksDefault,
|
|
5125
|
+
getTestExecutionStepAttachmentPathTestExecutionIdOrKeyRegExp,
|
|
5126
|
+
getTestExecutionTestStepAttachmentsReferencePathTestExecutionIdOrKeyRegExp,
|
|
5127
|
+
getTestExecutionTestStepAttachmentsReferencePathTestStepIdRegExp,
|
|
3060
5128
|
getTestExecutionTestSteps200ResponseOneStartAtMin,
|
|
3061
5129
|
getTestExecutionTestSteps200ResponseOneTotalMin,
|
|
3062
5130
|
getTestExecutionTestStepsPathTestExecutionIdOrKeyRegExp,
|
|
@@ -3070,6 +5138,7 @@ export {
|
|
|
3070
5138
|
getTestPlan200ResponseNameMax,
|
|
3071
5139
|
getTestPlan200ResponseNameRegExp,
|
|
3072
5140
|
getTestPlan200ResponseOwnerAccountIdRegExp,
|
|
5141
|
+
getTestPlanAttachmentPathTestPlanIdOrKeyRegExp,
|
|
3073
5142
|
getTestPlanPathTestPlanIdOrKeyRegExp,
|
|
3074
5143
|
listEnvironments200ResponseOneStartAtMin,
|
|
3075
5144
|
listEnvironments200ResponseOneTotalMin,
|
|
@@ -3160,6 +5229,16 @@ export {
|
|
|
3160
5229
|
listTestCycles200ResponseTwoValuesItemKeyRegExp,
|
|
3161
5230
|
listTestCycles200ResponseTwoValuesItemNameRegExp,
|
|
3162
5231
|
listTestCycles200ResponseTwoValuesItemOwnerAccountIdRegExp,
|
|
5232
|
+
listTestCyclesCursorPaginated200ResponseOneLimitMin,
|
|
5233
|
+
listTestCyclesCursorPaginated200ResponseOneNextStartAtIdMin,
|
|
5234
|
+
listTestCyclesCursorPaginated200ResponseTwoValuesItemKeyRegExp,
|
|
5235
|
+
listTestCyclesCursorPaginated200ResponseTwoValuesItemNameRegExp,
|
|
5236
|
+
listTestCyclesCursorPaginated200ResponseTwoValuesItemOwnerAccountIdRegExp,
|
|
5237
|
+
listTestCyclesCursorPaginatedQueryLimitDefault,
|
|
5238
|
+
listTestCyclesCursorPaginatedQueryLimitMax,
|
|
5239
|
+
listTestCyclesCursorPaginatedQueryProjectKeyRegExp,
|
|
5240
|
+
listTestCyclesCursorPaginatedQueryStartAtIdDefault,
|
|
5241
|
+
listTestCyclesCursorPaginatedQueryStartAtIdMin,
|
|
3163
5242
|
listTestCyclesQueryMaxResultsDefault,
|
|
3164
5243
|
listTestCyclesQueryProjectKeyRegExp,
|
|
3165
5244
|
listTestCyclesQueryStartAtDefault,
|
|
@@ -3205,6 +5284,18 @@ export {
|
|
|
3205
5284
|
listTestPlans200ResponseTwoValuesItemNameMax,
|
|
3206
5285
|
listTestPlans200ResponseTwoValuesItemNameRegExp,
|
|
3207
5286
|
listTestPlans200ResponseTwoValuesItemOwnerAccountIdRegExp,
|
|
5287
|
+
listTestPlansCursorPaginated200ResponseOneLimitMin,
|
|
5288
|
+
listTestPlansCursorPaginated200ResponseOneNextStartAtIdMin,
|
|
5289
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemKeyRegExp,
|
|
5290
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemLabelsMax,
|
|
5291
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemNameMax,
|
|
5292
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemNameRegExp,
|
|
5293
|
+
listTestPlansCursorPaginated200ResponseTwoValuesItemOwnerAccountIdRegExp,
|
|
5294
|
+
listTestPlansCursorPaginatedQueryLimitDefault,
|
|
5295
|
+
listTestPlansCursorPaginatedQueryLimitMax,
|
|
5296
|
+
listTestPlansCursorPaginatedQueryProjectKeyRegExp,
|
|
5297
|
+
listTestPlansCursorPaginatedQueryStartAtIdDefault,
|
|
5298
|
+
listTestPlansCursorPaginatedQueryStartAtIdMin,
|
|
3208
5299
|
listTestPlansQueryMaxResultsDefault,
|
|
3209
5300
|
listTestPlansQueryProjectKeyRegExp,
|
|
3210
5301
|
listTestPlansQueryStartAtDefault,
|
|
@@ -3241,5 +5332,11 @@ export {
|
|
|
3241
5332
|
updateTestExecutionBodyExecutedByIdRegExp,
|
|
3242
5333
|
updateTestExecutionBodyExecutionTimeMin,
|
|
3243
5334
|
updateTestExecutionBodyStatusNameMax,
|
|
3244
|
-
updateTestExecutionPathTestExecutionIdOrKeyRegExp
|
|
5335
|
+
updateTestExecutionPathTestExecutionIdOrKeyRegExp,
|
|
5336
|
+
uploadTestCaseAttachmentPathFileNameMax,
|
|
5337
|
+
uploadTestCaseAttachmentPathTestCaseKeyRegExp,
|
|
5338
|
+
uploadTestCycleAttachmentPathFileNameMax,
|
|
5339
|
+
uploadTestCycleAttachmentPathTestCycleIdOrKeyRegExp,
|
|
5340
|
+
uploadTestExecutionAttachmentPathFileNameMax,
|
|
5341
|
+
uploadTestExecutionAttachmentPathTestExecutionIdOrKeyRegExp
|
|
3245
5342
|
};
|