@larksuiteoapi/node-sdk 1.50.1 → 1.51.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.
Files changed (4) hide show
  1. package/es/index.js +174 -100
  2. package/lib/index.js +174 -100
  3. package/package.json +1 -1
  4. package/types/index.d.ts +34 -0
package/lib/index.js CHANGED
@@ -120,7 +120,15 @@ defaultHttpInstance.interceptors.request.use((req) => {
120
120
  }
121
121
  return req;
122
122
  }, undefined, { synchronous: true });
123
- defaultHttpInstance.interceptors.response.use((resp) => resp.data);
123
+ defaultHttpInstance.interceptors.response.use((resp) => {
124
+ if (resp.config['$return_headers']) {
125
+ return {
126
+ data: resp.data,
127
+ headers: resp.headers
128
+ };
129
+ }
130
+ return resp.data;
131
+ });
124
132
 
125
133
  exports.AppType = void 0;
126
134
  (function (AppType) {
@@ -301,6 +309,7 @@ class Client$16 {
301
309
  params,
302
310
  responseType: "stream",
303
311
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
312
+ $return_headers: true,
304
313
  })
305
314
  .catch((e) => {
306
315
  this.logger.error(formatErrors(e));
@@ -308,7 +317,7 @@ class Client$16 {
308
317
  });
309
318
  const checkIsReadable = () => {
310
319
  const consumedError = "The stream has already been consumed";
311
- if (!res.readable) {
320
+ if (!res.data.readable) {
312
321
  this.logger.error(consumedError);
313
322
  throw new Error(consumedError);
314
323
  }
@@ -324,13 +333,14 @@ class Client$16 {
324
333
  writableStream.on("error", (e) => {
325
334
  reject(e);
326
335
  });
327
- res.pipe(writableStream);
336
+ res.data.pipe(writableStream);
328
337
  });
329
338
  }),
330
339
  getReadableStream: () => {
331
340
  checkIsReadable();
332
- return res;
341
+ return res.data;
333
342
  },
343
+ headers: res.headers,
334
344
  };
335
345
  }),
336
346
  },
@@ -557,6 +567,7 @@ class Client$16 {
557
567
  params,
558
568
  responseType: "stream",
559
569
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
570
+ $return_headers: true,
560
571
  })
561
572
  .catch((e) => {
562
573
  this.logger.error(formatErrors(e));
@@ -564,7 +575,7 @@ class Client$16 {
564
575
  });
565
576
  const checkIsReadable = () => {
566
577
  const consumedError = "The stream has already been consumed";
567
- if (!res.readable) {
578
+ if (!res.data.readable) {
568
579
  this.logger.error(consumedError);
569
580
  throw new Error(consumedError);
570
581
  }
@@ -580,13 +591,14 @@ class Client$16 {
580
591
  writableStream.on("error", (e) => {
581
592
  reject(e);
582
593
  });
583
- res.pipe(writableStream);
594
+ res.data.pipe(writableStream);
584
595
  });
585
596
  }),
586
597
  getReadableStream: () => {
587
598
  checkIsReadable();
588
- return res;
599
+ return res.data;
589
600
  },
601
+ headers: res.headers,
590
602
  };
591
603
  }),
592
604
  /**
@@ -822,6 +834,7 @@ class Client$16 {
822
834
  params,
823
835
  responseType: "stream",
824
836
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
837
+ $return_headers: true,
825
838
  })
826
839
  .catch((e) => {
827
840
  this.logger.error(formatErrors(e));
@@ -829,7 +842,7 @@ class Client$16 {
829
842
  });
830
843
  const checkIsReadable = () => {
831
844
  const consumedError = "The stream has already been consumed";
832
- if (!res.readable) {
845
+ if (!res.data.readable) {
833
846
  this.logger.error(consumedError);
834
847
  throw new Error(consumedError);
835
848
  }
@@ -845,13 +858,14 @@ class Client$16 {
845
858
  writableStream.on("error", (e) => {
846
859
  reject(e);
847
860
  });
848
- res.pipe(writableStream);
861
+ res.data.pipe(writableStream);
849
862
  });
850
863
  }),
851
864
  getReadableStream: () => {
852
865
  checkIsReadable();
853
- return res;
866
+ return res.data;
854
867
  },
868
+ headers: res.headers,
855
869
  };
856
870
  }),
857
871
  },
@@ -1080,6 +1094,7 @@ class Client$16 {
1080
1094
  params,
1081
1095
  responseType: "stream",
1082
1096
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
1097
+ $return_headers: true,
1083
1098
  })
1084
1099
  .catch((e) => {
1085
1100
  this.logger.error(formatErrors(e));
@@ -1087,7 +1102,7 @@ class Client$16 {
1087
1102
  });
1088
1103
  const checkIsReadable = () => {
1089
1104
  const consumedError = "The stream has already been consumed";
1090
- if (!res.readable) {
1105
+ if (!res.data.readable) {
1091
1106
  this.logger.error(consumedError);
1092
1107
  throw new Error(consumedError);
1093
1108
  }
@@ -1103,13 +1118,14 @@ class Client$16 {
1103
1118
  writableStream.on("error", (e) => {
1104
1119
  reject(e);
1105
1120
  });
1106
- res.pipe(writableStream);
1121
+ res.data.pipe(writableStream);
1107
1122
  });
1108
1123
  }),
1109
1124
  getReadableStream: () => {
1110
1125
  checkIsReadable();
1111
- return res;
1126
+ return res.data;
1112
1127
  },
1128
+ headers: res.headers,
1113
1129
  };
1114
1130
  }),
1115
1131
  /**
@@ -8148,6 +8164,7 @@ class Client$10 extends Client$11 {
8148
8164
  params,
8149
8165
  responseType: "stream",
8150
8166
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
8167
+ $return_headers: true,
8151
8168
  })
8152
8169
  .catch((e) => {
8153
8170
  this.logger.error(formatErrors(e));
@@ -8155,7 +8172,7 @@ class Client$10 extends Client$11 {
8155
8172
  });
8156
8173
  const checkIsReadable = () => {
8157
8174
  const consumedError = "The stream has already been consumed";
8158
- if (!res.readable) {
8175
+ if (!res.data.readable) {
8159
8176
  this.logger.error(consumedError);
8160
8177
  throw new Error(consumedError);
8161
8178
  }
@@ -8171,13 +8188,14 @@ class Client$10 extends Client$11 {
8171
8188
  writableStream.on("error", (e) => {
8172
8189
  reject(e);
8173
8190
  });
8174
- res.pipe(writableStream);
8191
+ res.data.pipe(writableStream);
8175
8192
  });
8176
8193
  }),
8177
8194
  getReadableStream: () => {
8178
8195
  checkIsReadable();
8179
- return res;
8196
+ return res.data;
8180
8197
  },
8198
+ headers: res.headers,
8181
8199
  };
8182
8200
  }),
8183
8201
  /**
@@ -9368,6 +9386,7 @@ class Client$10 extends Client$11 {
9368
9386
  params,
9369
9387
  responseType: "stream",
9370
9388
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
9389
+ $return_headers: true,
9371
9390
  })
9372
9391
  .catch((e) => {
9373
9392
  this.logger.error(formatErrors(e));
@@ -9375,7 +9394,7 @@ class Client$10 extends Client$11 {
9375
9394
  });
9376
9395
  const checkIsReadable = () => {
9377
9396
  const consumedError = "The stream has already been consumed";
9378
- if (!res.readable) {
9397
+ if (!res.data.readable) {
9379
9398
  this.logger.error(consumedError);
9380
9399
  throw new Error(consumedError);
9381
9400
  }
@@ -9391,13 +9410,14 @@ class Client$10 extends Client$11 {
9391
9410
  writableStream.on("error", (e) => {
9392
9411
  reject(e);
9393
9412
  });
9394
- res.pipe(writableStream);
9413
+ res.data.pipe(writableStream);
9395
9414
  });
9396
9415
  }),
9397
9416
  getReadableStream: () => {
9398
9417
  checkIsReadable();
9399
- return res;
9418
+ return res.data;
9400
9419
  },
9420
+ headers: res.headers,
9401
9421
  };
9402
9422
  }),
9403
9423
  /**
@@ -11416,6 +11436,7 @@ class Client$Y extends Client$Z {
11416
11436
  params,
11417
11437
  responseType: "stream",
11418
11438
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
11439
+ $return_headers: true,
11419
11440
  })
11420
11441
  .catch((e) => {
11421
11442
  this.logger.error(formatErrors(e));
@@ -11423,7 +11444,7 @@ class Client$Y extends Client$Z {
11423
11444
  });
11424
11445
  const checkIsReadable = () => {
11425
11446
  const consumedError = "The stream has already been consumed";
11426
- if (!res.readable) {
11447
+ if (!res.data.readable) {
11427
11448
  this.logger.error(consumedError);
11428
11449
  throw new Error(consumedError);
11429
11450
  }
@@ -11439,13 +11460,14 @@ class Client$Y extends Client$Z {
11439
11460
  writableStream.on("error", (e) => {
11440
11461
  reject(e);
11441
11462
  });
11442
- res.pipe(writableStream);
11463
+ res.data.pipe(writableStream);
11443
11464
  });
11444
11465
  }),
11445
11466
  getReadableStream: () => {
11446
11467
  checkIsReadable();
11447
- return res;
11468
+ return res.data;
11448
11469
  },
11470
+ headers: res.headers,
11449
11471
  };
11450
11472
  }),
11451
11473
  /**
@@ -11952,6 +11974,7 @@ class Client$Y extends Client$Z {
11952
11974
  params,
11953
11975
  responseType: "stream",
11954
11976
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
11977
+ $return_headers: true,
11955
11978
  })
11956
11979
  .catch((e) => {
11957
11980
  this.logger.error(formatErrors(e));
@@ -11959,7 +11982,7 @@ class Client$Y extends Client$Z {
11959
11982
  });
11960
11983
  const checkIsReadable = () => {
11961
11984
  const consumedError = "The stream has already been consumed";
11962
- if (!res.readable) {
11985
+ if (!res.data.readable) {
11963
11986
  this.logger.error(consumedError);
11964
11987
  throw new Error(consumedError);
11965
11988
  }
@@ -11975,13 +11998,14 @@ class Client$Y extends Client$Z {
11975
11998
  writableStream.on("error", (e) => {
11976
11999
  reject(e);
11977
12000
  });
11978
- res.pipe(writableStream);
12001
+ res.data.pipe(writableStream);
11979
12002
  });
11980
12003
  }),
11981
12004
  getReadableStream: () => {
11982
12005
  checkIsReadable();
11983
- return res;
12006
+ return res.data;
11984
12007
  },
12008
+ headers: res.headers,
11985
12009
  };
11986
12010
  }),
11987
12011
  /**
@@ -15883,6 +15907,7 @@ class Client$U extends Client$V {
15883
15907
  params,
15884
15908
  responseType: "stream",
15885
15909
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
15910
+ $return_headers: true,
15886
15911
  })
15887
15912
  .catch((e) => {
15888
15913
  this.logger.error(formatErrors(e));
@@ -15890,7 +15915,7 @@ class Client$U extends Client$V {
15890
15915
  });
15891
15916
  const checkIsReadable = () => {
15892
15917
  const consumedError = "The stream has already been consumed";
15893
- if (!res.readable) {
15918
+ if (!res.data.readable) {
15894
15919
  this.logger.error(consumedError);
15895
15920
  throw new Error(consumedError);
15896
15921
  }
@@ -15906,13 +15931,14 @@ class Client$U extends Client$V {
15906
15931
  writableStream.on("error", (e) => {
15907
15932
  reject(e);
15908
15933
  });
15909
- res.pipe(writableStream);
15934
+ res.data.pipe(writableStream);
15910
15935
  });
15911
15936
  }),
15912
15937
  getReadableStream: () => {
15913
15938
  checkIsReadable();
15914
- return res;
15939
+ return res.data;
15915
15940
  },
15941
+ headers: res.headers,
15916
15942
  };
15917
15943
  }),
15918
15944
  },
@@ -25501,6 +25527,7 @@ class Client$M extends Client$N {
25501
25527
  params,
25502
25528
  responseType: "stream",
25503
25529
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
25530
+ $return_headers: true,
25504
25531
  })
25505
25532
  .catch((e) => {
25506
25533
  this.logger.error(formatErrors(e));
@@ -25508,7 +25535,7 @@ class Client$M extends Client$N {
25508
25535
  });
25509
25536
  const checkIsReadable = () => {
25510
25537
  const consumedError = "The stream has already been consumed";
25511
- if (!res.readable) {
25538
+ if (!res.data.readable) {
25512
25539
  this.logger.error(consumedError);
25513
25540
  throw new Error(consumedError);
25514
25541
  }
@@ -25524,13 +25551,14 @@ class Client$M extends Client$N {
25524
25551
  writableStream.on("error", (e) => {
25525
25552
  reject(e);
25526
25553
  });
25527
- res.pipe(writableStream);
25554
+ res.data.pipe(writableStream);
25528
25555
  });
25529
25556
  }),
25530
25557
  getReadableStream: () => {
25531
25558
  checkIsReadable();
25532
- return res;
25559
+ return res.data;
25533
25560
  },
25561
+ headers: res.headers,
25534
25562
  };
25535
25563
  }),
25536
25564
  },
@@ -28326,6 +28354,7 @@ class Client$M extends Client$N {
28326
28354
  params,
28327
28355
  responseType: "stream",
28328
28356
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
28357
+ $return_headers: true,
28329
28358
  })
28330
28359
  .catch((e) => {
28331
28360
  this.logger.error(formatErrors(e));
@@ -28333,7 +28362,7 @@ class Client$M extends Client$N {
28333
28362
  });
28334
28363
  const checkIsReadable = () => {
28335
28364
  const consumedError = "The stream has already been consumed";
28336
- if (!res.readable) {
28365
+ if (!res.data.readable) {
28337
28366
  this.logger.error(consumedError);
28338
28367
  throw new Error(consumedError);
28339
28368
  }
@@ -28349,13 +28378,14 @@ class Client$M extends Client$N {
28349
28378
  writableStream.on("error", (e) => {
28350
28379
  reject(e);
28351
28380
  });
28352
- res.pipe(writableStream);
28381
+ res.data.pipe(writableStream);
28353
28382
  });
28354
28383
  }),
28355
28384
  getReadableStream: () => {
28356
28385
  checkIsReadable();
28357
- return res;
28386
+ return res.data;
28358
28387
  },
28388
+ headers: res.headers,
28359
28389
  };
28360
28390
  }),
28361
28391
  },
@@ -37474,6 +37504,7 @@ class Client$G extends Client$H {
37474
37504
  params,
37475
37505
  responseType: "stream",
37476
37506
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
37507
+ $return_headers: true,
37477
37508
  })
37478
37509
  .catch((e) => {
37479
37510
  this.logger.error(formatErrors(e));
@@ -37481,7 +37512,7 @@ class Client$G extends Client$H {
37481
37512
  });
37482
37513
  const checkIsReadable = () => {
37483
37514
  const consumedError = "The stream has already been consumed";
37484
- if (!res.readable) {
37515
+ if (!res.data.readable) {
37485
37516
  this.logger.error(consumedError);
37486
37517
  throw new Error(consumedError);
37487
37518
  }
@@ -37497,13 +37528,14 @@ class Client$G extends Client$H {
37497
37528
  writableStream.on("error", (e) => {
37498
37529
  reject(e);
37499
37530
  });
37500
- res.pipe(writableStream);
37531
+ res.data.pipe(writableStream);
37501
37532
  });
37502
37533
  }),
37503
37534
  getReadableStream: () => {
37504
37535
  checkIsReadable();
37505
- return res;
37536
+ return res.data;
37506
37537
  },
37538
+ headers: res.headers,
37507
37539
  };
37508
37540
  }),
37509
37541
  /**
@@ -37997,6 +38029,7 @@ class Client$G extends Client$H {
37997
38029
  params,
37998
38030
  responseType: "stream",
37999
38031
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
38032
+ $return_headers: true,
38000
38033
  })
38001
38034
  .catch((e) => {
38002
38035
  this.logger.error(formatErrors(e));
@@ -38004,7 +38037,7 @@ class Client$G extends Client$H {
38004
38037
  });
38005
38038
  const checkIsReadable = () => {
38006
38039
  const consumedError = "The stream has already been consumed";
38007
- if (!res.readable) {
38040
+ if (!res.data.readable) {
38008
38041
  this.logger.error(consumedError);
38009
38042
  throw new Error(consumedError);
38010
38043
  }
@@ -38020,13 +38053,14 @@ class Client$G extends Client$H {
38020
38053
  writableStream.on("error", (e) => {
38021
38054
  reject(e);
38022
38055
  });
38023
- res.pipe(writableStream);
38056
+ res.data.pipe(writableStream);
38024
38057
  });
38025
38058
  }),
38026
38059
  getReadableStream: () => {
38027
38060
  checkIsReadable();
38028
- return res;
38061
+ return res.data;
38029
38062
  },
38063
+ headers: res.headers,
38030
38064
  };
38031
38065
  }),
38032
38066
  /**
@@ -38768,6 +38802,7 @@ class Client$G extends Client$H {
38768
38802
  params,
38769
38803
  responseType: "stream",
38770
38804
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
38805
+ $return_headers: true,
38771
38806
  })
38772
38807
  .catch((e) => {
38773
38808
  this.logger.error(formatErrors(e));
@@ -38775,7 +38810,7 @@ class Client$G extends Client$H {
38775
38810
  });
38776
38811
  const checkIsReadable = () => {
38777
38812
  const consumedError = "The stream has already been consumed";
38778
- if (!res.readable) {
38813
+ if (!res.data.readable) {
38779
38814
  this.logger.error(consumedError);
38780
38815
  throw new Error(consumedError);
38781
38816
  }
@@ -38791,13 +38826,14 @@ class Client$G extends Client$H {
38791
38826
  writableStream.on("error", (e) => {
38792
38827
  reject(e);
38793
38828
  });
38794
- res.pipe(writableStream);
38829
+ res.data.pipe(writableStream);
38795
38830
  });
38796
38831
  }),
38797
38832
  getReadableStream: () => {
38798
38833
  checkIsReadable();
38799
- return res;
38834
+ return res.data;
38800
38835
  },
38836
+ headers: res.headers,
38801
38837
  };
38802
38838
  }),
38803
38839
  /**
@@ -39290,6 +39326,7 @@ class Client$G extends Client$H {
39290
39326
  params,
39291
39327
  responseType: "stream",
39292
39328
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
39329
+ $return_headers: true,
39293
39330
  })
39294
39331
  .catch((e) => {
39295
39332
  this.logger.error(formatErrors(e));
@@ -39297,7 +39334,7 @@ class Client$G extends Client$H {
39297
39334
  });
39298
39335
  const checkIsReadable = () => {
39299
39336
  const consumedError = "The stream has already been consumed";
39300
- if (!res.readable) {
39337
+ if (!res.data.readable) {
39301
39338
  this.logger.error(consumedError);
39302
39339
  throw new Error(consumedError);
39303
39340
  }
@@ -39313,13 +39350,14 @@ class Client$G extends Client$H {
39313
39350
  writableStream.on("error", (e) => {
39314
39351
  reject(e);
39315
39352
  });
39316
- res.pipe(writableStream);
39353
+ res.data.pipe(writableStream);
39317
39354
  });
39318
39355
  }),
39319
39356
  getReadableStream: () => {
39320
39357
  checkIsReadable();
39321
- return res;
39358
+ return res.data;
39322
39359
  },
39360
+ headers: res.headers,
39323
39361
  };
39324
39362
  }),
39325
39363
  /**
@@ -39817,6 +39855,7 @@ class Client$G extends Client$H {
39817
39855
  params,
39818
39856
  responseType: "stream",
39819
39857
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
39858
+ $return_headers: true,
39820
39859
  })
39821
39860
  .catch((e) => {
39822
39861
  this.logger.error(formatErrors(e));
@@ -39824,7 +39863,7 @@ class Client$G extends Client$H {
39824
39863
  });
39825
39864
  const checkIsReadable = () => {
39826
39865
  const consumedError = "The stream has already been consumed";
39827
- if (!res.readable) {
39866
+ if (!res.data.readable) {
39828
39867
  this.logger.error(consumedError);
39829
39868
  throw new Error(consumedError);
39830
39869
  }
@@ -39840,13 +39879,14 @@ class Client$G extends Client$H {
39840
39879
  writableStream.on("error", (e) => {
39841
39880
  reject(e);
39842
39881
  });
39843
- res.pipe(writableStream);
39882
+ res.data.pipe(writableStream);
39844
39883
  });
39845
39884
  }),
39846
39885
  getReadableStream: () => {
39847
39886
  checkIsReadable();
39848
- return res;
39887
+ return res.data;
39849
39888
  },
39889
+ headers: res.headers,
39850
39890
  };
39851
39891
  }),
39852
39892
  /**
@@ -40594,6 +40634,7 @@ class Client$G extends Client$H {
40594
40634
  params,
40595
40635
  responseType: "stream",
40596
40636
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
40637
+ $return_headers: true,
40597
40638
  })
40598
40639
  .catch((e) => {
40599
40640
  this.logger.error(formatErrors(e));
@@ -40601,7 +40642,7 @@ class Client$G extends Client$H {
40601
40642
  });
40602
40643
  const checkIsReadable = () => {
40603
40644
  const consumedError = "The stream has already been consumed";
40604
- if (!res.readable) {
40645
+ if (!res.data.readable) {
40605
40646
  this.logger.error(consumedError);
40606
40647
  throw new Error(consumedError);
40607
40648
  }
@@ -40617,13 +40658,14 @@ class Client$G extends Client$H {
40617
40658
  writableStream.on("error", (e) => {
40618
40659
  reject(e);
40619
40660
  });
40620
- res.pipe(writableStream);
40661
+ res.data.pipe(writableStream);
40621
40662
  });
40622
40663
  }),
40623
40664
  getReadableStream: () => {
40624
40665
  checkIsReadable();
40625
- return res;
40666
+ return res.data;
40626
40667
  },
40668
+ headers: res.headers,
40627
40669
  };
40628
40670
  }),
40629
40671
  /**
@@ -41245,6 +41287,7 @@ class Client$E extends Client$F {
41245
41287
  params,
41246
41288
  responseType: "stream",
41247
41289
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
41290
+ $return_headers: true,
41248
41291
  })
41249
41292
  .catch((e) => {
41250
41293
  this.logger.error(formatErrors(e));
@@ -41252,7 +41295,7 @@ class Client$E extends Client$F {
41252
41295
  });
41253
41296
  const checkIsReadable = () => {
41254
41297
  const consumedError = "The stream has already been consumed";
41255
- if (!res.readable) {
41298
+ if (!res.data.readable) {
41256
41299
  this.logger.error(consumedError);
41257
41300
  throw new Error(consumedError);
41258
41301
  }
@@ -41268,13 +41311,14 @@ class Client$E extends Client$F {
41268
41311
  writableStream.on("error", (e) => {
41269
41312
  reject(e);
41270
41313
  });
41271
- res.pipe(writableStream);
41314
+ res.data.pipe(writableStream);
41272
41315
  });
41273
41316
  }),
41274
41317
  getReadableStream: () => {
41275
41318
  checkIsReadable();
41276
- return res;
41319
+ return res.data;
41277
41320
  },
41321
+ headers: res.headers,
41278
41322
  };
41279
41323
  }),
41280
41324
  },
@@ -41385,6 +41429,7 @@ class Client$E extends Client$F {
41385
41429
  params,
41386
41430
  responseType: "stream",
41387
41431
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
41432
+ $return_headers: true,
41388
41433
  })
41389
41434
  .catch((e) => {
41390
41435
  this.logger.error(formatErrors(e));
@@ -41392,7 +41437,7 @@ class Client$E extends Client$F {
41392
41437
  });
41393
41438
  const checkIsReadable = () => {
41394
41439
  const consumedError = "The stream has already been consumed";
41395
- if (!res.readable) {
41440
+ if (!res.data.readable) {
41396
41441
  this.logger.error(consumedError);
41397
41442
  throw new Error(consumedError);
41398
41443
  }
@@ -41408,13 +41453,14 @@ class Client$E extends Client$F {
41408
41453
  writableStream.on("error", (e) => {
41409
41454
  reject(e);
41410
41455
  });
41411
- res.pipe(writableStream);
41456
+ res.data.pipe(writableStream);
41412
41457
  });
41413
41458
  }),
41414
41459
  getReadableStream: () => {
41415
41460
  checkIsReadable();
41416
- return res;
41461
+ return res.data;
41417
41462
  },
41463
+ headers: res.headers,
41418
41464
  };
41419
41465
  }),
41420
41466
  },
@@ -42376,6 +42422,7 @@ class Client$y extends Client$z {
42376
42422
  params,
42377
42423
  responseType: "stream",
42378
42424
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
42425
+ $return_headers: true,
42379
42426
  })
42380
42427
  .catch((e) => {
42381
42428
  this.logger.error(formatErrors(e));
@@ -42383,7 +42430,7 @@ class Client$y extends Client$z {
42383
42430
  });
42384
42431
  const checkIsReadable = () => {
42385
42432
  const consumedError = "The stream has already been consumed";
42386
- if (!res.readable) {
42433
+ if (!res.data.readable) {
42387
42434
  this.logger.error(consumedError);
42388
42435
  throw new Error(consumedError);
42389
42436
  }
@@ -42399,13 +42446,14 @@ class Client$y extends Client$z {
42399
42446
  writableStream.on("error", (e) => {
42400
42447
  reject(e);
42401
42448
  });
42402
- res.pipe(writableStream);
42449
+ res.data.pipe(writableStream);
42403
42450
  });
42404
42451
  }),
42405
42452
  getReadableStream: () => {
42406
42453
  checkIsReadable();
42407
- return res;
42454
+ return res.data;
42408
42455
  },
42456
+ headers: res.headers,
42409
42457
  };
42410
42458
  }),
42411
42459
  /**
@@ -42963,6 +43011,7 @@ class Client$y extends Client$z {
42963
43011
  params,
42964
43012
  responseType: "stream",
42965
43013
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
43014
+ $return_headers: true,
42966
43015
  })
42967
43016
  .catch((e) => {
42968
43017
  this.logger.error(formatErrors(e));
@@ -42970,7 +43019,7 @@ class Client$y extends Client$z {
42970
43019
  });
42971
43020
  const checkIsReadable = () => {
42972
43021
  const consumedError = "The stream has already been consumed";
42973
- if (!res.readable) {
43022
+ if (!res.data.readable) {
42974
43023
  this.logger.error(consumedError);
42975
43024
  throw new Error(consumedError);
42976
43025
  }
@@ -42986,13 +43035,14 @@ class Client$y extends Client$z {
42986
43035
  writableStream.on("error", (e) => {
42987
43036
  reject(e);
42988
43037
  });
42989
- res.pipe(writableStream);
43038
+ res.data.pipe(writableStream);
42990
43039
  });
42991
43040
  }),
42992
43041
  getReadableStream: () => {
42993
43042
  checkIsReadable();
42994
- return res;
43043
+ return res.data;
42995
43044
  },
43045
+ headers: res.headers,
42996
43046
  };
42997
43047
  }),
42998
43048
  /**
@@ -43896,6 +43946,7 @@ class Client$y extends Client$z {
43896
43946
  params,
43897
43947
  responseType: "stream",
43898
43948
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
43949
+ $return_headers: true,
43899
43950
  })
43900
43951
  .catch((e) => {
43901
43952
  this.logger.error(formatErrors(e));
@@ -43903,7 +43954,7 @@ class Client$y extends Client$z {
43903
43954
  });
43904
43955
  const checkIsReadable = () => {
43905
43956
  const consumedError = "The stream has already been consumed";
43906
- if (!res.readable) {
43957
+ if (!res.data.readable) {
43907
43958
  this.logger.error(consumedError);
43908
43959
  throw new Error(consumedError);
43909
43960
  }
@@ -43919,13 +43970,14 @@ class Client$y extends Client$z {
43919
43970
  writableStream.on("error", (e) => {
43920
43971
  reject(e);
43921
43972
  });
43922
- res.pipe(writableStream);
43973
+ res.data.pipe(writableStream);
43923
43974
  });
43924
43975
  }),
43925
43976
  getReadableStream: () => {
43926
43977
  checkIsReadable();
43927
- return res;
43978
+ return res.data;
43928
43979
  },
43980
+ headers: res.headers,
43929
43981
  };
43930
43982
  }),
43931
43983
  /**
@@ -44487,6 +44539,7 @@ class Client$y extends Client$z {
44487
44539
  params,
44488
44540
  responseType: "stream",
44489
44541
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
44542
+ $return_headers: true,
44490
44543
  })
44491
44544
  .catch((e) => {
44492
44545
  this.logger.error(formatErrors(e));
@@ -44494,7 +44547,7 @@ class Client$y extends Client$z {
44494
44547
  });
44495
44548
  const checkIsReadable = () => {
44496
44549
  const consumedError = "The stream has already been consumed";
44497
- if (!res.readable) {
44550
+ if (!res.data.readable) {
44498
44551
  this.logger.error(consumedError);
44499
44552
  throw new Error(consumedError);
44500
44553
  }
@@ -44510,13 +44563,14 @@ class Client$y extends Client$z {
44510
44563
  writableStream.on("error", (e) => {
44511
44564
  reject(e);
44512
44565
  });
44513
- res.pipe(writableStream);
44566
+ res.data.pipe(writableStream);
44514
44567
  });
44515
44568
  }),
44516
44569
  getReadableStream: () => {
44517
44570
  checkIsReadable();
44518
- return res;
44571
+ return res.data;
44519
44572
  },
44573
+ headers: res.headers,
44520
44574
  };
44521
44575
  }),
44522
44576
  /**
@@ -58327,6 +58381,7 @@ class Client$v extends Client$w {
58327
58381
  params,
58328
58382
  responseType: "stream",
58329
58383
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
58384
+ $return_headers: true,
58330
58385
  })
58331
58386
  .catch((e) => {
58332
58387
  this.logger.error(formatErrors(e));
@@ -58334,7 +58389,7 @@ class Client$v extends Client$w {
58334
58389
  });
58335
58390
  const checkIsReadable = () => {
58336
58391
  const consumedError = "The stream has already been consumed";
58337
- if (!res.readable) {
58392
+ if (!res.data.readable) {
58338
58393
  this.logger.error(consumedError);
58339
58394
  throw new Error(consumedError);
58340
58395
  }
@@ -58350,13 +58405,14 @@ class Client$v extends Client$w {
58350
58405
  writableStream.on("error", (e) => {
58351
58406
  reject(e);
58352
58407
  });
58353
- res.pipe(writableStream);
58408
+ res.data.pipe(writableStream);
58354
58409
  });
58355
58410
  }),
58356
58411
  getReadableStream: () => {
58357
58412
  checkIsReadable();
58358
- return res;
58413
+ return res.data;
58359
58414
  },
58415
+ headers: res.headers,
58360
58416
  };
58361
58417
  }),
58362
58418
  },
@@ -58414,6 +58470,7 @@ class Client$v extends Client$w {
58414
58470
  params,
58415
58471
  responseType: "stream",
58416
58472
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
58473
+ $return_headers: true,
58417
58474
  })
58418
58475
  .catch((e) => {
58419
58476
  this.logger.error(formatErrors(e));
@@ -58421,7 +58478,7 @@ class Client$v extends Client$w {
58421
58478
  });
58422
58479
  const checkIsReadable = () => {
58423
58480
  const consumedError = "The stream has already been consumed";
58424
- if (!res.readable) {
58481
+ if (!res.data.readable) {
58425
58482
  this.logger.error(consumedError);
58426
58483
  throw new Error(consumedError);
58427
58484
  }
@@ -58437,13 +58494,14 @@ class Client$v extends Client$w {
58437
58494
  writableStream.on("error", (e) => {
58438
58495
  reject(e);
58439
58496
  });
58440
- res.pipe(writableStream);
58497
+ res.data.pipe(writableStream);
58441
58498
  });
58442
58499
  }),
58443
58500
  getReadableStream: () => {
58444
58501
  checkIsReadable();
58445
- return res;
58502
+ return res.data;
58446
58503
  },
58504
+ headers: res.headers,
58447
58505
  };
58448
58506
  }),
58449
58507
  },
@@ -59129,6 +59187,7 @@ class Client$v extends Client$w {
59129
59187
  params,
59130
59188
  responseType: "stream",
59131
59189
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
59190
+ $return_headers: true,
59132
59191
  })
59133
59192
  .catch((e) => {
59134
59193
  this.logger.error(formatErrors(e));
@@ -59136,7 +59195,7 @@ class Client$v extends Client$w {
59136
59195
  });
59137
59196
  const checkIsReadable = () => {
59138
59197
  const consumedError = "The stream has already been consumed";
59139
- if (!res.readable) {
59198
+ if (!res.data.readable) {
59140
59199
  this.logger.error(consumedError);
59141
59200
  throw new Error(consumedError);
59142
59201
  }
@@ -59152,13 +59211,14 @@ class Client$v extends Client$w {
59152
59211
  writableStream.on("error", (e) => {
59153
59212
  reject(e);
59154
59213
  });
59155
- res.pipe(writableStream);
59214
+ res.data.pipe(writableStream);
59156
59215
  });
59157
59216
  }),
59158
59217
  getReadableStream: () => {
59159
59218
  checkIsReadable();
59160
- return res;
59219
+ return res.data;
59161
59220
  },
59221
+ headers: res.headers,
59162
59222
  };
59163
59223
  }),
59164
59224
  },
@@ -60530,6 +60590,7 @@ class Client$v extends Client$w {
60530
60590
  params,
60531
60591
  responseType: "stream",
60532
60592
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
60593
+ $return_headers: true,
60533
60594
  })
60534
60595
  .catch((e) => {
60535
60596
  this.logger.error(formatErrors(e));
@@ -60537,7 +60598,7 @@ class Client$v extends Client$w {
60537
60598
  });
60538
60599
  const checkIsReadable = () => {
60539
60600
  const consumedError = "The stream has already been consumed";
60540
- if (!res.readable) {
60601
+ if (!res.data.readable) {
60541
60602
  this.logger.error(consumedError);
60542
60603
  throw new Error(consumedError);
60543
60604
  }
@@ -60553,13 +60614,14 @@ class Client$v extends Client$w {
60553
60614
  writableStream.on("error", (e) => {
60554
60615
  reject(e);
60555
60616
  });
60556
- res.pipe(writableStream);
60617
+ res.data.pipe(writableStream);
60557
60618
  });
60558
60619
  }),
60559
60620
  getReadableStream: () => {
60560
60621
  checkIsReadable();
60561
- return res;
60622
+ return res.data;
60562
60623
  },
60624
+ headers: res.headers,
60563
60625
  };
60564
60626
  }),
60565
60627
  },
@@ -60617,6 +60679,7 @@ class Client$v extends Client$w {
60617
60679
  params,
60618
60680
  responseType: "stream",
60619
60681
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
60682
+ $return_headers: true,
60620
60683
  })
60621
60684
  .catch((e) => {
60622
60685
  this.logger.error(formatErrors(e));
@@ -60624,7 +60687,7 @@ class Client$v extends Client$w {
60624
60687
  });
60625
60688
  const checkIsReadable = () => {
60626
60689
  const consumedError = "The stream has already been consumed";
60627
- if (!res.readable) {
60690
+ if (!res.data.readable) {
60628
60691
  this.logger.error(consumedError);
60629
60692
  throw new Error(consumedError);
60630
60693
  }
@@ -60640,13 +60703,14 @@ class Client$v extends Client$w {
60640
60703
  writableStream.on("error", (e) => {
60641
60704
  reject(e);
60642
60705
  });
60643
- res.pipe(writableStream);
60706
+ res.data.pipe(writableStream);
60644
60707
  });
60645
60708
  }),
60646
60709
  getReadableStream: () => {
60647
60710
  checkIsReadable();
60648
- return res;
60711
+ return res.data;
60649
60712
  },
60713
+ headers: res.headers,
60650
60714
  };
60651
60715
  }),
60652
60716
  },
@@ -61336,6 +61400,7 @@ class Client$v extends Client$w {
61336
61400
  params,
61337
61401
  responseType: "stream",
61338
61402
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
61403
+ $return_headers: true,
61339
61404
  })
61340
61405
  .catch((e) => {
61341
61406
  this.logger.error(formatErrors(e));
@@ -61343,7 +61408,7 @@ class Client$v extends Client$w {
61343
61408
  });
61344
61409
  const checkIsReadable = () => {
61345
61410
  const consumedError = "The stream has already been consumed";
61346
- if (!res.readable) {
61411
+ if (!res.data.readable) {
61347
61412
  this.logger.error(consumedError);
61348
61413
  throw new Error(consumedError);
61349
61414
  }
@@ -61359,13 +61424,14 @@ class Client$v extends Client$w {
61359
61424
  writableStream.on("error", (e) => {
61360
61425
  reject(e);
61361
61426
  });
61362
- res.pipe(writableStream);
61427
+ res.data.pipe(writableStream);
61363
61428
  });
61364
61429
  }),
61365
61430
  getReadableStream: () => {
61366
61431
  checkIsReadable();
61367
- return res;
61432
+ return res.data;
61368
61433
  },
61434
+ headers: res.headers,
61369
61435
  };
61370
61436
  }),
61371
61437
  },
@@ -62260,6 +62326,7 @@ class Client$u extends Client$v {
62260
62326
  params,
62261
62327
  responseType: "stream",
62262
62328
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
62329
+ $return_headers: true,
62263
62330
  })
62264
62331
  .catch((e) => {
62265
62332
  this.logger.error(formatErrors(e));
@@ -62267,7 +62334,7 @@ class Client$u extends Client$v {
62267
62334
  });
62268
62335
  const checkIsReadable = () => {
62269
62336
  const consumedError = "The stream has already been consumed";
62270
- if (!res.readable) {
62337
+ if (!res.data.readable) {
62271
62338
  this.logger.error(consumedError);
62272
62339
  throw new Error(consumedError);
62273
62340
  }
@@ -62283,13 +62350,14 @@ class Client$u extends Client$v {
62283
62350
  writableStream.on("error", (e) => {
62284
62351
  reject(e);
62285
62352
  });
62286
- res.pipe(writableStream);
62353
+ res.data.pipe(writableStream);
62287
62354
  });
62288
62355
  }),
62289
62356
  getReadableStream: () => {
62290
62357
  checkIsReadable();
62291
- return res;
62358
+ return res.data;
62292
62359
  },
62360
+ headers: res.headers,
62293
62361
  };
62294
62362
  }),
62295
62363
  /**
@@ -66886,6 +66954,7 @@ class Client$q extends Client$r {
66886
66954
  params,
66887
66955
  responseType: "stream",
66888
66956
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
66957
+ $return_headers: true,
66889
66958
  })
66890
66959
  .catch((e) => {
66891
66960
  this.logger.error(formatErrors(e));
@@ -66893,7 +66962,7 @@ class Client$q extends Client$r {
66893
66962
  });
66894
66963
  const checkIsReadable = () => {
66895
66964
  const consumedError = "The stream has already been consumed";
66896
- if (!res.readable) {
66965
+ if (!res.data.readable) {
66897
66966
  this.logger.error(consumedError);
66898
66967
  throw new Error(consumedError);
66899
66968
  }
@@ -66909,13 +66978,14 @@ class Client$q extends Client$r {
66909
66978
  writableStream.on("error", (e) => {
66910
66979
  reject(e);
66911
66980
  });
66912
- res.pipe(writableStream);
66981
+ res.data.pipe(writableStream);
66913
66982
  });
66914
66983
  }),
66915
66984
  getReadableStream: () => {
66916
66985
  checkIsReadable();
66917
- return res;
66986
+ return res.data;
66918
66987
  },
66988
+ headers: res.headers,
66919
66989
  };
66920
66990
  }),
66921
66991
  },
@@ -76134,6 +76204,7 @@ class Client$4 extends Client$5 {
76134
76204
  params,
76135
76205
  responseType: "stream",
76136
76206
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
76207
+ $return_headers: true,
76137
76208
  })
76138
76209
  .catch((e) => {
76139
76210
  this.logger.error(formatErrors(e));
@@ -76141,7 +76212,7 @@ class Client$4 extends Client$5 {
76141
76212
  });
76142
76213
  const checkIsReadable = () => {
76143
76214
  const consumedError = "The stream has already been consumed";
76144
- if (!res.readable) {
76215
+ if (!res.data.readable) {
76145
76216
  this.logger.error(consumedError);
76146
76217
  throw new Error(consumedError);
76147
76218
  }
@@ -76157,13 +76228,14 @@ class Client$4 extends Client$5 {
76157
76228
  writableStream.on("error", (e) => {
76158
76229
  reject(e);
76159
76230
  });
76160
- res.pipe(writableStream);
76231
+ res.data.pipe(writableStream);
76161
76232
  });
76162
76233
  }),
76163
76234
  getReadableStream: () => {
76164
76235
  checkIsReadable();
76165
- return res;
76236
+ return res.data;
76166
76237
  },
76238
+ headers: res.headers,
76167
76239
  };
76168
76240
  }),
76169
76241
  /**
@@ -78028,6 +78100,7 @@ class Client$4 extends Client$5 {
78028
78100
  params,
78029
78101
  responseType: "stream",
78030
78102
  paramsSerializer: (params) => qs.stringify(params, { arrayFormat: "repeat" }),
78103
+ $return_headers: true,
78031
78104
  })
78032
78105
  .catch((e) => {
78033
78106
  this.logger.error(formatErrors(e));
@@ -78035,7 +78108,7 @@ class Client$4 extends Client$5 {
78035
78108
  });
78036
78109
  const checkIsReadable = () => {
78037
78110
  const consumedError = "The stream has already been consumed";
78038
- if (!res.readable) {
78111
+ if (!res.data.readable) {
78039
78112
  this.logger.error(consumedError);
78040
78113
  throw new Error(consumedError);
78041
78114
  }
@@ -78051,13 +78124,14 @@ class Client$4 extends Client$5 {
78051
78124
  writableStream.on("error", (e) => {
78052
78125
  reject(e);
78053
78126
  });
78054
- res.pipe(writableStream);
78127
+ res.data.pipe(writableStream);
78055
78128
  });
78056
78129
  }),
78057
78130
  getReadableStream: () => {
78058
78131
  checkIsReadable();
78059
- return res;
78132
+ return res.data;
78060
78133
  },
78134
+ headers: res.headers,
78061
78135
  };
78062
78136
  }),
78063
78137
  /**