@larksuiteoapi/node-sdk 1.50.0 → 1.51.0-alpha.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 +176 -101
  2. package/lib/index.js +176 -101
  3. package/package.json +1 -1
  4. package/types/index.d.ts +35 -0
package/es/index.js CHANGED
@@ -105,7 +105,15 @@ defaultHttpInstance.interceptors.request.use((req) => {
105
105
  }
106
106
  return req;
107
107
  }, undefined, { synchronous: true });
108
- defaultHttpInstance.interceptors.response.use((resp) => resp.data);
108
+ defaultHttpInstance.interceptors.response.use((resp) => {
109
+ if (resp.config['$return_headers']) {
110
+ return {
111
+ data: resp.data,
112
+ headers: resp.headers
113
+ };
114
+ }
115
+ return resp.data;
116
+ });
109
117
 
110
118
  var AppType;
111
119
  (function (AppType) {
@@ -286,6 +294,7 @@ class Client$16 {
286
294
  params,
287
295
  responseType: "stream",
288
296
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
297
+ $return_headers: true,
289
298
  })
290
299
  .catch((e) => {
291
300
  this.logger.error(formatErrors(e));
@@ -293,7 +302,7 @@ class Client$16 {
293
302
  });
294
303
  const checkIsReadable = () => {
295
304
  const consumedError = "The stream has already been consumed";
296
- if (!res.readable) {
305
+ if (!res.data.readable) {
297
306
  this.logger.error(consumedError);
298
307
  throw new Error(consumedError);
299
308
  }
@@ -309,13 +318,14 @@ class Client$16 {
309
318
  writableStream.on("error", (e) => {
310
319
  reject(e);
311
320
  });
312
- res.pipe(writableStream);
321
+ res.data.pipe(writableStream);
313
322
  });
314
323
  }),
315
324
  getReadableStream: () => {
316
325
  checkIsReadable();
317
- return res;
326
+ return res.data;
318
327
  },
328
+ headers: res.headers,
319
329
  };
320
330
  }),
321
331
  },
@@ -542,6 +552,7 @@ class Client$16 {
542
552
  params,
543
553
  responseType: "stream",
544
554
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
555
+ $return_headers: true,
545
556
  })
546
557
  .catch((e) => {
547
558
  this.logger.error(formatErrors(e));
@@ -549,7 +560,7 @@ class Client$16 {
549
560
  });
550
561
  const checkIsReadable = () => {
551
562
  const consumedError = "The stream has already been consumed";
552
- if (!res.readable) {
563
+ if (!res.data.readable) {
553
564
  this.logger.error(consumedError);
554
565
  throw new Error(consumedError);
555
566
  }
@@ -565,13 +576,14 @@ class Client$16 {
565
576
  writableStream.on("error", (e) => {
566
577
  reject(e);
567
578
  });
568
- res.pipe(writableStream);
579
+ res.data.pipe(writableStream);
569
580
  });
570
581
  }),
571
582
  getReadableStream: () => {
572
583
  checkIsReadable();
573
- return res;
584
+ return res.data;
574
585
  },
586
+ headers: res.headers,
575
587
  };
576
588
  }),
577
589
  /**
@@ -807,6 +819,7 @@ class Client$16 {
807
819
  params,
808
820
  responseType: "stream",
809
821
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
822
+ $return_headers: true,
810
823
  })
811
824
  .catch((e) => {
812
825
  this.logger.error(formatErrors(e));
@@ -814,7 +827,7 @@ class Client$16 {
814
827
  });
815
828
  const checkIsReadable = () => {
816
829
  const consumedError = "The stream has already been consumed";
817
- if (!res.readable) {
830
+ if (!res.data.readable) {
818
831
  this.logger.error(consumedError);
819
832
  throw new Error(consumedError);
820
833
  }
@@ -830,13 +843,14 @@ class Client$16 {
830
843
  writableStream.on("error", (e) => {
831
844
  reject(e);
832
845
  });
833
- res.pipe(writableStream);
846
+ res.data.pipe(writableStream);
834
847
  });
835
848
  }),
836
849
  getReadableStream: () => {
837
850
  checkIsReadable();
838
- return res;
851
+ return res.data;
839
852
  },
853
+ headers: res.headers,
840
854
  };
841
855
  }),
842
856
  },
@@ -1065,6 +1079,7 @@ class Client$16 {
1065
1079
  params,
1066
1080
  responseType: "stream",
1067
1081
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
1082
+ $return_headers: true,
1068
1083
  })
1069
1084
  .catch((e) => {
1070
1085
  this.logger.error(formatErrors(e));
@@ -1072,7 +1087,7 @@ class Client$16 {
1072
1087
  });
1073
1088
  const checkIsReadable = () => {
1074
1089
  const consumedError = "The stream has already been consumed";
1075
- if (!res.readable) {
1090
+ if (!res.data.readable) {
1076
1091
  this.logger.error(consumedError);
1077
1092
  throw new Error(consumedError);
1078
1093
  }
@@ -1088,13 +1103,14 @@ class Client$16 {
1088
1103
  writableStream.on("error", (e) => {
1089
1104
  reject(e);
1090
1105
  });
1091
- res.pipe(writableStream);
1106
+ res.data.pipe(writableStream);
1092
1107
  });
1093
1108
  }),
1094
1109
  getReadableStream: () => {
1095
1110
  checkIsReadable();
1096
- return res;
1111
+ return res.data;
1097
1112
  },
1113
+ headers: res.headers,
1098
1114
  };
1099
1115
  }),
1100
1116
  /**
@@ -8133,6 +8149,7 @@ class Client$10 extends Client$11 {
8133
8149
  params,
8134
8150
  responseType: "stream",
8135
8151
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
8152
+ $return_headers: true,
8136
8153
  })
8137
8154
  .catch((e) => {
8138
8155
  this.logger.error(formatErrors(e));
@@ -8140,7 +8157,7 @@ class Client$10 extends Client$11 {
8140
8157
  });
8141
8158
  const checkIsReadable = () => {
8142
8159
  const consumedError = "The stream has already been consumed";
8143
- if (!res.readable) {
8160
+ if (!res.data.readable) {
8144
8161
  this.logger.error(consumedError);
8145
8162
  throw new Error(consumedError);
8146
8163
  }
@@ -8156,13 +8173,14 @@ class Client$10 extends Client$11 {
8156
8173
  writableStream.on("error", (e) => {
8157
8174
  reject(e);
8158
8175
  });
8159
- res.pipe(writableStream);
8176
+ res.data.pipe(writableStream);
8160
8177
  });
8161
8178
  }),
8162
8179
  getReadableStream: () => {
8163
8180
  checkIsReadable();
8164
- return res;
8181
+ return res.data;
8165
8182
  },
8183
+ headers: res.headers,
8166
8184
  };
8167
8185
  }),
8168
8186
  /**
@@ -9353,6 +9371,7 @@ class Client$10 extends Client$11 {
9353
9371
  params,
9354
9372
  responseType: "stream",
9355
9373
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
9374
+ $return_headers: true,
9356
9375
  })
9357
9376
  .catch((e) => {
9358
9377
  this.logger.error(formatErrors(e));
@@ -9360,7 +9379,7 @@ class Client$10 extends Client$11 {
9360
9379
  });
9361
9380
  const checkIsReadable = () => {
9362
9381
  const consumedError = "The stream has already been consumed";
9363
- if (!res.readable) {
9382
+ if (!res.data.readable) {
9364
9383
  this.logger.error(consumedError);
9365
9384
  throw new Error(consumedError);
9366
9385
  }
@@ -9376,13 +9395,14 @@ class Client$10 extends Client$11 {
9376
9395
  writableStream.on("error", (e) => {
9377
9396
  reject(e);
9378
9397
  });
9379
- res.pipe(writableStream);
9398
+ res.data.pipe(writableStream);
9380
9399
  });
9381
9400
  }),
9382
9401
  getReadableStream: () => {
9383
9402
  checkIsReadable();
9384
- return res;
9403
+ return res.data;
9385
9404
  },
9405
+ headers: res.headers,
9386
9406
  };
9387
9407
  }),
9388
9408
  /**
@@ -11401,6 +11421,7 @@ class Client$Y extends Client$Z {
11401
11421
  params,
11402
11422
  responseType: "stream",
11403
11423
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
11424
+ $return_headers: true,
11404
11425
  })
11405
11426
  .catch((e) => {
11406
11427
  this.logger.error(formatErrors(e));
@@ -11408,7 +11429,7 @@ class Client$Y extends Client$Z {
11408
11429
  });
11409
11430
  const checkIsReadable = () => {
11410
11431
  const consumedError = "The stream has already been consumed";
11411
- if (!res.readable) {
11432
+ if (!res.data.readable) {
11412
11433
  this.logger.error(consumedError);
11413
11434
  throw new Error(consumedError);
11414
11435
  }
@@ -11424,13 +11445,14 @@ class Client$Y extends Client$Z {
11424
11445
  writableStream.on("error", (e) => {
11425
11446
  reject(e);
11426
11447
  });
11427
- res.pipe(writableStream);
11448
+ res.data.pipe(writableStream);
11428
11449
  });
11429
11450
  }),
11430
11451
  getReadableStream: () => {
11431
11452
  checkIsReadable();
11432
- return res;
11453
+ return res.data;
11433
11454
  },
11455
+ headers: res.headers,
11434
11456
  };
11435
11457
  }),
11436
11458
  /**
@@ -11937,6 +11959,7 @@ class Client$Y extends Client$Z {
11937
11959
  params,
11938
11960
  responseType: "stream",
11939
11961
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
11962
+ $return_headers: true,
11940
11963
  })
11941
11964
  .catch((e) => {
11942
11965
  this.logger.error(formatErrors(e));
@@ -11944,7 +11967,7 @@ class Client$Y extends Client$Z {
11944
11967
  });
11945
11968
  const checkIsReadable = () => {
11946
11969
  const consumedError = "The stream has already been consumed";
11947
- if (!res.readable) {
11970
+ if (!res.data.readable) {
11948
11971
  this.logger.error(consumedError);
11949
11972
  throw new Error(consumedError);
11950
11973
  }
@@ -11960,13 +11983,14 @@ class Client$Y extends Client$Z {
11960
11983
  writableStream.on("error", (e) => {
11961
11984
  reject(e);
11962
11985
  });
11963
- res.pipe(writableStream);
11986
+ res.data.pipe(writableStream);
11964
11987
  });
11965
11988
  }),
11966
11989
  getReadableStream: () => {
11967
11990
  checkIsReadable();
11968
- return res;
11991
+ return res.data;
11969
11992
  },
11993
+ headers: res.headers,
11970
11994
  };
11971
11995
  }),
11972
11996
  /**
@@ -15868,6 +15892,7 @@ class Client$U extends Client$V {
15868
15892
  params,
15869
15893
  responseType: "stream",
15870
15894
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
15895
+ $return_headers: true,
15871
15896
  })
15872
15897
  .catch((e) => {
15873
15898
  this.logger.error(formatErrors(e));
@@ -15875,7 +15900,7 @@ class Client$U extends Client$V {
15875
15900
  });
15876
15901
  const checkIsReadable = () => {
15877
15902
  const consumedError = "The stream has already been consumed";
15878
- if (!res.readable) {
15903
+ if (!res.data.readable) {
15879
15904
  this.logger.error(consumedError);
15880
15905
  throw new Error(consumedError);
15881
15906
  }
@@ -15891,13 +15916,14 @@ class Client$U extends Client$V {
15891
15916
  writableStream.on("error", (e) => {
15892
15917
  reject(e);
15893
15918
  });
15894
- res.pipe(writableStream);
15919
+ res.data.pipe(writableStream);
15895
15920
  });
15896
15921
  }),
15897
15922
  getReadableStream: () => {
15898
15923
  checkIsReadable();
15899
- return res;
15924
+ return res.data;
15900
15925
  },
15926
+ headers: res.headers,
15901
15927
  };
15902
15928
  }),
15903
15929
  },
@@ -25486,6 +25512,7 @@ class Client$M extends Client$N {
25486
25512
  params,
25487
25513
  responseType: "stream",
25488
25514
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
25515
+ $return_headers: true,
25489
25516
  })
25490
25517
  .catch((e) => {
25491
25518
  this.logger.error(formatErrors(e));
@@ -25493,7 +25520,7 @@ class Client$M extends Client$N {
25493
25520
  });
25494
25521
  const checkIsReadable = () => {
25495
25522
  const consumedError = "The stream has already been consumed";
25496
- if (!res.readable) {
25523
+ if (!res.data.readable) {
25497
25524
  this.logger.error(consumedError);
25498
25525
  throw new Error(consumedError);
25499
25526
  }
@@ -25509,13 +25536,14 @@ class Client$M extends Client$N {
25509
25536
  writableStream.on("error", (e) => {
25510
25537
  reject(e);
25511
25538
  });
25512
- res.pipe(writableStream);
25539
+ res.data.pipe(writableStream);
25513
25540
  });
25514
25541
  }),
25515
25542
  getReadableStream: () => {
25516
25543
  checkIsReadable();
25517
- return res;
25544
+ return res.data;
25518
25545
  },
25546
+ headers: res.headers,
25519
25547
  };
25520
25548
  }),
25521
25549
  },
@@ -28311,6 +28339,7 @@ class Client$M extends Client$N {
28311
28339
  params,
28312
28340
  responseType: "stream",
28313
28341
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
28342
+ $return_headers: true,
28314
28343
  })
28315
28344
  .catch((e) => {
28316
28345
  this.logger.error(formatErrors(e));
@@ -28318,7 +28347,7 @@ class Client$M extends Client$N {
28318
28347
  });
28319
28348
  const checkIsReadable = () => {
28320
28349
  const consumedError = "The stream has already been consumed";
28321
- if (!res.readable) {
28350
+ if (!res.data.readable) {
28322
28351
  this.logger.error(consumedError);
28323
28352
  throw new Error(consumedError);
28324
28353
  }
@@ -28334,13 +28363,14 @@ class Client$M extends Client$N {
28334
28363
  writableStream.on("error", (e) => {
28335
28364
  reject(e);
28336
28365
  });
28337
- res.pipe(writableStream);
28366
+ res.data.pipe(writableStream);
28338
28367
  });
28339
28368
  }),
28340
28369
  getReadableStream: () => {
28341
28370
  checkIsReadable();
28342
- return res;
28371
+ return res.data;
28343
28372
  },
28373
+ headers: res.headers,
28344
28374
  };
28345
28375
  }),
28346
28376
  },
@@ -37459,6 +37489,7 @@ class Client$G extends Client$H {
37459
37489
  params,
37460
37490
  responseType: "stream",
37461
37491
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
37492
+ $return_headers: true,
37462
37493
  })
37463
37494
  .catch((e) => {
37464
37495
  this.logger.error(formatErrors(e));
@@ -37466,7 +37497,7 @@ class Client$G extends Client$H {
37466
37497
  });
37467
37498
  const checkIsReadable = () => {
37468
37499
  const consumedError = "The stream has already been consumed";
37469
- if (!res.readable) {
37500
+ if (!res.data.readable) {
37470
37501
  this.logger.error(consumedError);
37471
37502
  throw new Error(consumedError);
37472
37503
  }
@@ -37482,13 +37513,14 @@ class Client$G extends Client$H {
37482
37513
  writableStream.on("error", (e) => {
37483
37514
  reject(e);
37484
37515
  });
37485
- res.pipe(writableStream);
37516
+ res.data.pipe(writableStream);
37486
37517
  });
37487
37518
  }),
37488
37519
  getReadableStream: () => {
37489
37520
  checkIsReadable();
37490
- return res;
37521
+ return res.data;
37491
37522
  },
37523
+ headers: res.headers,
37492
37524
  };
37493
37525
  }),
37494
37526
  /**
@@ -37982,6 +38014,7 @@ class Client$G extends Client$H {
37982
38014
  params,
37983
38015
  responseType: "stream",
37984
38016
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
38017
+ $return_headers: true,
37985
38018
  })
37986
38019
  .catch((e) => {
37987
38020
  this.logger.error(formatErrors(e));
@@ -37989,7 +38022,7 @@ class Client$G extends Client$H {
37989
38022
  });
37990
38023
  const checkIsReadable = () => {
37991
38024
  const consumedError = "The stream has already been consumed";
37992
- if (!res.readable) {
38025
+ if (!res.data.readable) {
37993
38026
  this.logger.error(consumedError);
37994
38027
  throw new Error(consumedError);
37995
38028
  }
@@ -38005,13 +38038,14 @@ class Client$G extends Client$H {
38005
38038
  writableStream.on("error", (e) => {
38006
38039
  reject(e);
38007
38040
  });
38008
- res.pipe(writableStream);
38041
+ res.data.pipe(writableStream);
38009
38042
  });
38010
38043
  }),
38011
38044
  getReadableStream: () => {
38012
38045
  checkIsReadable();
38013
- return res;
38046
+ return res.data;
38014
38047
  },
38048
+ headers: res.headers,
38015
38049
  };
38016
38050
  }),
38017
38051
  /**
@@ -38753,6 +38787,7 @@ class Client$G extends Client$H {
38753
38787
  params,
38754
38788
  responseType: "stream",
38755
38789
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
38790
+ $return_headers: true,
38756
38791
  })
38757
38792
  .catch((e) => {
38758
38793
  this.logger.error(formatErrors(e));
@@ -38760,7 +38795,7 @@ class Client$G extends Client$H {
38760
38795
  });
38761
38796
  const checkIsReadable = () => {
38762
38797
  const consumedError = "The stream has already been consumed";
38763
- if (!res.readable) {
38798
+ if (!res.data.readable) {
38764
38799
  this.logger.error(consumedError);
38765
38800
  throw new Error(consumedError);
38766
38801
  }
@@ -38776,13 +38811,14 @@ class Client$G extends Client$H {
38776
38811
  writableStream.on("error", (e) => {
38777
38812
  reject(e);
38778
38813
  });
38779
- res.pipe(writableStream);
38814
+ res.data.pipe(writableStream);
38780
38815
  });
38781
38816
  }),
38782
38817
  getReadableStream: () => {
38783
38818
  checkIsReadable();
38784
- return res;
38819
+ return res.data;
38785
38820
  },
38821
+ headers: res.headers,
38786
38822
  };
38787
38823
  }),
38788
38824
  /**
@@ -39275,6 +39311,7 @@ class Client$G extends Client$H {
39275
39311
  params,
39276
39312
  responseType: "stream",
39277
39313
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
39314
+ $return_headers: true,
39278
39315
  })
39279
39316
  .catch((e) => {
39280
39317
  this.logger.error(formatErrors(e));
@@ -39282,7 +39319,7 @@ class Client$G extends Client$H {
39282
39319
  });
39283
39320
  const checkIsReadable = () => {
39284
39321
  const consumedError = "The stream has already been consumed";
39285
- if (!res.readable) {
39322
+ if (!res.data.readable) {
39286
39323
  this.logger.error(consumedError);
39287
39324
  throw new Error(consumedError);
39288
39325
  }
@@ -39298,13 +39335,14 @@ class Client$G extends Client$H {
39298
39335
  writableStream.on("error", (e) => {
39299
39336
  reject(e);
39300
39337
  });
39301
- res.pipe(writableStream);
39338
+ res.data.pipe(writableStream);
39302
39339
  });
39303
39340
  }),
39304
39341
  getReadableStream: () => {
39305
39342
  checkIsReadable();
39306
- return res;
39343
+ return res.data;
39307
39344
  },
39345
+ headers: res.headers,
39308
39346
  };
39309
39347
  }),
39310
39348
  /**
@@ -39802,6 +39840,7 @@ class Client$G extends Client$H {
39802
39840
  params,
39803
39841
  responseType: "stream",
39804
39842
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
39843
+ $return_headers: true,
39805
39844
  })
39806
39845
  .catch((e) => {
39807
39846
  this.logger.error(formatErrors(e));
@@ -39809,7 +39848,7 @@ class Client$G extends Client$H {
39809
39848
  });
39810
39849
  const checkIsReadable = () => {
39811
39850
  const consumedError = "The stream has already been consumed";
39812
- if (!res.readable) {
39851
+ if (!res.data.readable) {
39813
39852
  this.logger.error(consumedError);
39814
39853
  throw new Error(consumedError);
39815
39854
  }
@@ -39825,13 +39864,14 @@ class Client$G extends Client$H {
39825
39864
  writableStream.on("error", (e) => {
39826
39865
  reject(e);
39827
39866
  });
39828
- res.pipe(writableStream);
39867
+ res.data.pipe(writableStream);
39829
39868
  });
39830
39869
  }),
39831
39870
  getReadableStream: () => {
39832
39871
  checkIsReadable();
39833
- return res;
39872
+ return res.data;
39834
39873
  },
39874
+ headers: res.headers,
39835
39875
  };
39836
39876
  }),
39837
39877
  /**
@@ -40579,6 +40619,7 @@ class Client$G extends Client$H {
40579
40619
  params,
40580
40620
  responseType: "stream",
40581
40621
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
40622
+ $return_headers: true,
40582
40623
  })
40583
40624
  .catch((e) => {
40584
40625
  this.logger.error(formatErrors(e));
@@ -40586,7 +40627,7 @@ class Client$G extends Client$H {
40586
40627
  });
40587
40628
  const checkIsReadable = () => {
40588
40629
  const consumedError = "The stream has already been consumed";
40589
- if (!res.readable) {
40630
+ if (!res.data.readable) {
40590
40631
  this.logger.error(consumedError);
40591
40632
  throw new Error(consumedError);
40592
40633
  }
@@ -40602,13 +40643,14 @@ class Client$G extends Client$H {
40602
40643
  writableStream.on("error", (e) => {
40603
40644
  reject(e);
40604
40645
  });
40605
- res.pipe(writableStream);
40646
+ res.data.pipe(writableStream);
40606
40647
  });
40607
40648
  }),
40608
40649
  getReadableStream: () => {
40609
40650
  checkIsReadable();
40610
- return res;
40651
+ return res.data;
40611
40652
  },
40653
+ headers: res.headers,
40612
40654
  };
40613
40655
  }),
40614
40656
  /**
@@ -41230,6 +41272,7 @@ class Client$E extends Client$F {
41230
41272
  params,
41231
41273
  responseType: "stream",
41232
41274
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
41275
+ $return_headers: true,
41233
41276
  })
41234
41277
  .catch((e) => {
41235
41278
  this.logger.error(formatErrors(e));
@@ -41237,7 +41280,7 @@ class Client$E extends Client$F {
41237
41280
  });
41238
41281
  const checkIsReadable = () => {
41239
41282
  const consumedError = "The stream has already been consumed";
41240
- if (!res.readable) {
41283
+ if (!res.data.readable) {
41241
41284
  this.logger.error(consumedError);
41242
41285
  throw new Error(consumedError);
41243
41286
  }
@@ -41253,13 +41296,14 @@ class Client$E extends Client$F {
41253
41296
  writableStream.on("error", (e) => {
41254
41297
  reject(e);
41255
41298
  });
41256
- res.pipe(writableStream);
41299
+ res.data.pipe(writableStream);
41257
41300
  });
41258
41301
  }),
41259
41302
  getReadableStream: () => {
41260
41303
  checkIsReadable();
41261
- return res;
41304
+ return res.data;
41262
41305
  },
41306
+ headers: res.headers,
41263
41307
  };
41264
41308
  }),
41265
41309
  },
@@ -41370,6 +41414,7 @@ class Client$E extends Client$F {
41370
41414
  params,
41371
41415
  responseType: "stream",
41372
41416
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
41417
+ $return_headers: true,
41373
41418
  })
41374
41419
  .catch((e) => {
41375
41420
  this.logger.error(formatErrors(e));
@@ -41377,7 +41422,7 @@ class Client$E extends Client$F {
41377
41422
  });
41378
41423
  const checkIsReadable = () => {
41379
41424
  const consumedError = "The stream has already been consumed";
41380
- if (!res.readable) {
41425
+ if (!res.data.readable) {
41381
41426
  this.logger.error(consumedError);
41382
41427
  throw new Error(consumedError);
41383
41428
  }
@@ -41393,13 +41438,14 @@ class Client$E extends Client$F {
41393
41438
  writableStream.on("error", (e) => {
41394
41439
  reject(e);
41395
41440
  });
41396
- res.pipe(writableStream);
41441
+ res.data.pipe(writableStream);
41397
41442
  });
41398
41443
  }),
41399
41444
  getReadableStream: () => {
41400
41445
  checkIsReadable();
41401
- return res;
41446
+ return res.data;
41402
41447
  },
41448
+ headers: res.headers,
41403
41449
  };
41404
41450
  }),
41405
41451
  },
@@ -42361,6 +42407,7 @@ class Client$y extends Client$z {
42361
42407
  params,
42362
42408
  responseType: "stream",
42363
42409
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
42410
+ $return_headers: true,
42364
42411
  })
42365
42412
  .catch((e) => {
42366
42413
  this.logger.error(formatErrors(e));
@@ -42368,7 +42415,7 @@ class Client$y extends Client$z {
42368
42415
  });
42369
42416
  const checkIsReadable = () => {
42370
42417
  const consumedError = "The stream has already been consumed";
42371
- if (!res.readable) {
42418
+ if (!res.data.readable) {
42372
42419
  this.logger.error(consumedError);
42373
42420
  throw new Error(consumedError);
42374
42421
  }
@@ -42384,13 +42431,14 @@ class Client$y extends Client$z {
42384
42431
  writableStream.on("error", (e) => {
42385
42432
  reject(e);
42386
42433
  });
42387
- res.pipe(writableStream);
42434
+ res.data.pipe(writableStream);
42388
42435
  });
42389
42436
  }),
42390
42437
  getReadableStream: () => {
42391
42438
  checkIsReadable();
42392
- return res;
42439
+ return res.data;
42393
42440
  },
42441
+ headers: res.headers,
42394
42442
  };
42395
42443
  }),
42396
42444
  /**
@@ -42948,6 +42996,7 @@ class Client$y extends Client$z {
42948
42996
  params,
42949
42997
  responseType: "stream",
42950
42998
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
42999
+ $return_headers: true,
42951
43000
  })
42952
43001
  .catch((e) => {
42953
43002
  this.logger.error(formatErrors(e));
@@ -42955,7 +43004,7 @@ class Client$y extends Client$z {
42955
43004
  });
42956
43005
  const checkIsReadable = () => {
42957
43006
  const consumedError = "The stream has already been consumed";
42958
- if (!res.readable) {
43007
+ if (!res.data.readable) {
42959
43008
  this.logger.error(consumedError);
42960
43009
  throw new Error(consumedError);
42961
43010
  }
@@ -42971,13 +43020,14 @@ class Client$y extends Client$z {
42971
43020
  writableStream.on("error", (e) => {
42972
43021
  reject(e);
42973
43022
  });
42974
- res.pipe(writableStream);
43023
+ res.data.pipe(writableStream);
42975
43024
  });
42976
43025
  }),
42977
43026
  getReadableStream: () => {
42978
43027
  checkIsReadable();
42979
- return res;
43028
+ return res.data;
42980
43029
  },
43030
+ headers: res.headers,
42981
43031
  };
42982
43032
  }),
42983
43033
  /**
@@ -43881,6 +43931,7 @@ class Client$y extends Client$z {
43881
43931
  params,
43882
43932
  responseType: "stream",
43883
43933
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
43934
+ $return_headers: true,
43884
43935
  })
43885
43936
  .catch((e) => {
43886
43937
  this.logger.error(formatErrors(e));
@@ -43888,7 +43939,7 @@ class Client$y extends Client$z {
43888
43939
  });
43889
43940
  const checkIsReadable = () => {
43890
43941
  const consumedError = "The stream has already been consumed";
43891
- if (!res.readable) {
43942
+ if (!res.data.readable) {
43892
43943
  this.logger.error(consumedError);
43893
43944
  throw new Error(consumedError);
43894
43945
  }
@@ -43904,13 +43955,14 @@ class Client$y extends Client$z {
43904
43955
  writableStream.on("error", (e) => {
43905
43956
  reject(e);
43906
43957
  });
43907
- res.pipe(writableStream);
43958
+ res.data.pipe(writableStream);
43908
43959
  });
43909
43960
  }),
43910
43961
  getReadableStream: () => {
43911
43962
  checkIsReadable();
43912
- return res;
43963
+ return res.data;
43913
43964
  },
43965
+ headers: res.headers,
43914
43966
  };
43915
43967
  }),
43916
43968
  /**
@@ -44472,6 +44524,7 @@ class Client$y extends Client$z {
44472
44524
  params,
44473
44525
  responseType: "stream",
44474
44526
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
44527
+ $return_headers: true,
44475
44528
  })
44476
44529
  .catch((e) => {
44477
44530
  this.logger.error(formatErrors(e));
@@ -44479,7 +44532,7 @@ class Client$y extends Client$z {
44479
44532
  });
44480
44533
  const checkIsReadable = () => {
44481
44534
  const consumedError = "The stream has already been consumed";
44482
- if (!res.readable) {
44535
+ if (!res.data.readable) {
44483
44536
  this.logger.error(consumedError);
44484
44537
  throw new Error(consumedError);
44485
44538
  }
@@ -44495,13 +44548,14 @@ class Client$y extends Client$z {
44495
44548
  writableStream.on("error", (e) => {
44496
44549
  reject(e);
44497
44550
  });
44498
- res.pipe(writableStream);
44551
+ res.data.pipe(writableStream);
44499
44552
  });
44500
44553
  }),
44501
44554
  getReadableStream: () => {
44502
44555
  checkIsReadable();
44503
- return res;
44556
+ return res.data;
44504
44557
  },
44558
+ headers: res.headers,
44505
44559
  };
44506
44560
  }),
44507
44561
  /**
@@ -58312,6 +58366,7 @@ class Client$v extends Client$w {
58312
58366
  params,
58313
58367
  responseType: "stream",
58314
58368
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
58369
+ $return_headers: true,
58315
58370
  })
58316
58371
  .catch((e) => {
58317
58372
  this.logger.error(formatErrors(e));
@@ -58319,7 +58374,7 @@ class Client$v extends Client$w {
58319
58374
  });
58320
58375
  const checkIsReadable = () => {
58321
58376
  const consumedError = "The stream has already been consumed";
58322
- if (!res.readable) {
58377
+ if (!res.data.readable) {
58323
58378
  this.logger.error(consumedError);
58324
58379
  throw new Error(consumedError);
58325
58380
  }
@@ -58335,13 +58390,14 @@ class Client$v extends Client$w {
58335
58390
  writableStream.on("error", (e) => {
58336
58391
  reject(e);
58337
58392
  });
58338
- res.pipe(writableStream);
58393
+ res.data.pipe(writableStream);
58339
58394
  });
58340
58395
  }),
58341
58396
  getReadableStream: () => {
58342
58397
  checkIsReadable();
58343
- return res;
58398
+ return res.data;
58344
58399
  },
58400
+ headers: res.headers,
58345
58401
  };
58346
58402
  }),
58347
58403
  },
@@ -58399,6 +58455,7 @@ class Client$v extends Client$w {
58399
58455
  params,
58400
58456
  responseType: "stream",
58401
58457
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
58458
+ $return_headers: true,
58402
58459
  })
58403
58460
  .catch((e) => {
58404
58461
  this.logger.error(formatErrors(e));
@@ -58406,7 +58463,7 @@ class Client$v extends Client$w {
58406
58463
  });
58407
58464
  const checkIsReadable = () => {
58408
58465
  const consumedError = "The stream has already been consumed";
58409
- if (!res.readable) {
58466
+ if (!res.data.readable) {
58410
58467
  this.logger.error(consumedError);
58411
58468
  throw new Error(consumedError);
58412
58469
  }
@@ -58422,13 +58479,14 @@ class Client$v extends Client$w {
58422
58479
  writableStream.on("error", (e) => {
58423
58480
  reject(e);
58424
58481
  });
58425
- res.pipe(writableStream);
58482
+ res.data.pipe(writableStream);
58426
58483
  });
58427
58484
  }),
58428
58485
  getReadableStream: () => {
58429
58486
  checkIsReadable();
58430
- return res;
58487
+ return res.data;
58431
58488
  },
58489
+ headers: res.headers,
58432
58490
  };
58433
58491
  }),
58434
58492
  },
@@ -59114,6 +59172,7 @@ class Client$v extends Client$w {
59114
59172
  params,
59115
59173
  responseType: "stream",
59116
59174
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
59175
+ $return_headers: true,
59117
59176
  })
59118
59177
  .catch((e) => {
59119
59178
  this.logger.error(formatErrors(e));
@@ -59121,7 +59180,7 @@ class Client$v extends Client$w {
59121
59180
  });
59122
59181
  const checkIsReadable = () => {
59123
59182
  const consumedError = "The stream has already been consumed";
59124
- if (!res.readable) {
59183
+ if (!res.data.readable) {
59125
59184
  this.logger.error(consumedError);
59126
59185
  throw new Error(consumedError);
59127
59186
  }
@@ -59137,13 +59196,14 @@ class Client$v extends Client$w {
59137
59196
  writableStream.on("error", (e) => {
59138
59197
  reject(e);
59139
59198
  });
59140
- res.pipe(writableStream);
59199
+ res.data.pipe(writableStream);
59141
59200
  });
59142
59201
  }),
59143
59202
  getReadableStream: () => {
59144
59203
  checkIsReadable();
59145
- return res;
59204
+ return res.data;
59146
59205
  },
59206
+ headers: res.headers,
59147
59207
  };
59148
59208
  }),
59149
59209
  },
@@ -60515,6 +60575,7 @@ class Client$v extends Client$w {
60515
60575
  params,
60516
60576
  responseType: "stream",
60517
60577
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
60578
+ $return_headers: true,
60518
60579
  })
60519
60580
  .catch((e) => {
60520
60581
  this.logger.error(formatErrors(e));
@@ -60522,7 +60583,7 @@ class Client$v extends Client$w {
60522
60583
  });
60523
60584
  const checkIsReadable = () => {
60524
60585
  const consumedError = "The stream has already been consumed";
60525
- if (!res.readable) {
60586
+ if (!res.data.readable) {
60526
60587
  this.logger.error(consumedError);
60527
60588
  throw new Error(consumedError);
60528
60589
  }
@@ -60538,13 +60599,14 @@ class Client$v extends Client$w {
60538
60599
  writableStream.on("error", (e) => {
60539
60600
  reject(e);
60540
60601
  });
60541
- res.pipe(writableStream);
60602
+ res.data.pipe(writableStream);
60542
60603
  });
60543
60604
  }),
60544
60605
  getReadableStream: () => {
60545
60606
  checkIsReadable();
60546
- return res;
60607
+ return res.data;
60547
60608
  },
60609
+ headers: res.headers,
60548
60610
  };
60549
60611
  }),
60550
60612
  },
@@ -60602,6 +60664,7 @@ class Client$v extends Client$w {
60602
60664
  params,
60603
60665
  responseType: "stream",
60604
60666
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
60667
+ $return_headers: true,
60605
60668
  })
60606
60669
  .catch((e) => {
60607
60670
  this.logger.error(formatErrors(e));
@@ -60609,7 +60672,7 @@ class Client$v extends Client$w {
60609
60672
  });
60610
60673
  const checkIsReadable = () => {
60611
60674
  const consumedError = "The stream has already been consumed";
60612
- if (!res.readable) {
60675
+ if (!res.data.readable) {
60613
60676
  this.logger.error(consumedError);
60614
60677
  throw new Error(consumedError);
60615
60678
  }
@@ -60625,13 +60688,14 @@ class Client$v extends Client$w {
60625
60688
  writableStream.on("error", (e) => {
60626
60689
  reject(e);
60627
60690
  });
60628
- res.pipe(writableStream);
60691
+ res.data.pipe(writableStream);
60629
60692
  });
60630
60693
  }),
60631
60694
  getReadableStream: () => {
60632
60695
  checkIsReadable();
60633
- return res;
60696
+ return res.data;
60634
60697
  },
60698
+ headers: res.headers,
60635
60699
  };
60636
60700
  }),
60637
60701
  },
@@ -61321,6 +61385,7 @@ class Client$v extends Client$w {
61321
61385
  params,
61322
61386
  responseType: "stream",
61323
61387
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
61388
+ $return_headers: true,
61324
61389
  })
61325
61390
  .catch((e) => {
61326
61391
  this.logger.error(formatErrors(e));
@@ -61328,7 +61393,7 @@ class Client$v extends Client$w {
61328
61393
  });
61329
61394
  const checkIsReadable = () => {
61330
61395
  const consumedError = "The stream has already been consumed";
61331
- if (!res.readable) {
61396
+ if (!res.data.readable) {
61332
61397
  this.logger.error(consumedError);
61333
61398
  throw new Error(consumedError);
61334
61399
  }
@@ -61344,13 +61409,14 @@ class Client$v extends Client$w {
61344
61409
  writableStream.on("error", (e) => {
61345
61410
  reject(e);
61346
61411
  });
61347
- res.pipe(writableStream);
61412
+ res.data.pipe(writableStream);
61348
61413
  });
61349
61414
  }),
61350
61415
  getReadableStream: () => {
61351
61416
  checkIsReadable();
61352
- return res;
61417
+ return res.data;
61353
61418
  },
61419
+ headers: res.headers,
61354
61420
  };
61355
61421
  }),
61356
61422
  },
@@ -62245,6 +62311,7 @@ class Client$u extends Client$v {
62245
62311
  params,
62246
62312
  responseType: "stream",
62247
62313
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
62314
+ $return_headers: true,
62248
62315
  })
62249
62316
  .catch((e) => {
62250
62317
  this.logger.error(formatErrors(e));
@@ -62252,7 +62319,7 @@ class Client$u extends Client$v {
62252
62319
  });
62253
62320
  const checkIsReadable = () => {
62254
62321
  const consumedError = "The stream has already been consumed";
62255
- if (!res.readable) {
62322
+ if (!res.data.readable) {
62256
62323
  this.logger.error(consumedError);
62257
62324
  throw new Error(consumedError);
62258
62325
  }
@@ -62268,13 +62335,14 @@ class Client$u extends Client$v {
62268
62335
  writableStream.on("error", (e) => {
62269
62336
  reject(e);
62270
62337
  });
62271
- res.pipe(writableStream);
62338
+ res.data.pipe(writableStream);
62272
62339
  });
62273
62340
  }),
62274
62341
  getReadableStream: () => {
62275
62342
  checkIsReadable();
62276
- return res;
62343
+ return res.data;
62277
62344
  },
62345
+ headers: res.headers,
62278
62346
  };
62279
62347
  }),
62280
62348
  /**
@@ -66871,6 +66939,7 @@ class Client$q extends Client$r {
66871
66939
  params,
66872
66940
  responseType: "stream",
66873
66941
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
66942
+ $return_headers: true,
66874
66943
  })
66875
66944
  .catch((e) => {
66876
66945
  this.logger.error(formatErrors(e));
@@ -66878,7 +66947,7 @@ class Client$q extends Client$r {
66878
66947
  });
66879
66948
  const checkIsReadable = () => {
66880
66949
  const consumedError = "The stream has already been consumed";
66881
- if (!res.readable) {
66950
+ if (!res.data.readable) {
66882
66951
  this.logger.error(consumedError);
66883
66952
  throw new Error(consumedError);
66884
66953
  }
@@ -66894,13 +66963,14 @@ class Client$q extends Client$r {
66894
66963
  writableStream.on("error", (e) => {
66895
66964
  reject(e);
66896
66965
  });
66897
- res.pipe(writableStream);
66966
+ res.data.pipe(writableStream);
66898
66967
  });
66899
66968
  }),
66900
66969
  getReadableStream: () => {
66901
66970
  checkIsReadable();
66902
- return res;
66971
+ return res.data;
66903
66972
  },
66973
+ headers: res.headers,
66904
66974
  };
66905
66975
  }),
66906
66976
  },
@@ -76119,6 +76189,7 @@ class Client$4 extends Client$5 {
76119
76189
  params,
76120
76190
  responseType: "stream",
76121
76191
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
76192
+ $return_headers: true,
76122
76193
  })
76123
76194
  .catch((e) => {
76124
76195
  this.logger.error(formatErrors(e));
@@ -76126,7 +76197,7 @@ class Client$4 extends Client$5 {
76126
76197
  });
76127
76198
  const checkIsReadable = () => {
76128
76199
  const consumedError = "The stream has already been consumed";
76129
- if (!res.readable) {
76200
+ if (!res.data.readable) {
76130
76201
  this.logger.error(consumedError);
76131
76202
  throw new Error(consumedError);
76132
76203
  }
@@ -76142,13 +76213,14 @@ class Client$4 extends Client$5 {
76142
76213
  writableStream.on("error", (e) => {
76143
76214
  reject(e);
76144
76215
  });
76145
- res.pipe(writableStream);
76216
+ res.data.pipe(writableStream);
76146
76217
  });
76147
76218
  }),
76148
76219
  getReadableStream: () => {
76149
76220
  checkIsReadable();
76150
- return res;
76221
+ return res.data;
76151
76222
  },
76223
+ headers: res.headers,
76152
76224
  };
76153
76225
  }),
76154
76226
  /**
@@ -78013,6 +78085,7 @@ class Client$4 extends Client$5 {
78013
78085
  params,
78014
78086
  responseType: "stream",
78015
78087
  paramsSerializer: (params) => stringify(params, { arrayFormat: "repeat" }),
78088
+ $return_headers: true,
78016
78089
  })
78017
78090
  .catch((e) => {
78018
78091
  this.logger.error(formatErrors(e));
@@ -78020,7 +78093,7 @@ class Client$4 extends Client$5 {
78020
78093
  });
78021
78094
  const checkIsReadable = () => {
78022
78095
  const consumedError = "The stream has already been consumed";
78023
- if (!res.readable) {
78096
+ if (!res.data.readable) {
78024
78097
  this.logger.error(consumedError);
78025
78098
  throw new Error(consumedError);
78026
78099
  }
@@ -78036,13 +78109,14 @@ class Client$4 extends Client$5 {
78036
78109
  writableStream.on("error", (e) => {
78037
78110
  reject(e);
78038
78111
  });
78039
- res.pipe(writableStream);
78112
+ res.data.pipe(writableStream);
78040
78113
  });
78041
78114
  }),
78042
78115
  getReadableStream: () => {
78043
78116
  checkIsReadable();
78044
- return res;
78117
+ return res.data;
78045
78118
  },
78119
+ headers: res.headers,
78046
78120
  };
78047
78121
  }),
78048
78122
  /**
@@ -82916,7 +82990,8 @@ class WSClient {
82916
82990
  // consumed by gateway
82917
82991
  headers: {
82918
82992
  "locale": "zh",
82919
- }
82993
+ },
82994
+ timeout: 15000,
82920
82995
  });
82921
82996
  if (code !== ErrorCode.ok) {
82922
82997
  this.logger.error('[ws]', `code: ${code}, ${code === ErrorCode.system_busy ? msg : 'system busy'}`);