@smoothcodes/agent-client 0.1.3 → 0.2.1
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/CHANGELOG.md +39 -0
- package/dist/{chunk-X24QQ3X4.js → chunk-E4ZFXITU.js} +861 -211
- package/dist/chunk-E4ZFXITU.js.map +7 -0
- package/dist/index.js +1 -1
- package/dist/testing.js +1 -1
- package/dist/types/sdk/generated/ts-client/api/errors/BadRequestError.d.ts +3 -1
- package/dist/types/sdk/generated/ts-client/api/errors/ConflictError.d.ts +3 -1
- package/dist/types/sdk/generated/ts-client/api/errors/ForbiddenError.d.ts +3 -1
- package/dist/types/sdk/generated/ts-client/api/errors/InternalServerError.d.ts +3 -1
- package/dist/types/sdk/generated/ts-client/api/errors/TooManyRequestsError.d.ts +3 -1
- package/dist/types/sdk/generated/ts-client/api/errors/UnauthorizedError.d.ts +3 -1
- package/dist/types/sdk/generated/ts-client/api/resources/chats/client/Client.d.ts +3 -2
- package/dist/types/sdk/generated/ts-client/api/resources/chats/client/requests/CreateChat.d.ts +6 -0
- package/dist/types/sdk/generated/ts-client/api/resources/chats/client/requests/SwitchAgent.d.ts +21 -3
- package/dist/types/sdk/generated/ts-client/api/resources/providers/types/MyProvidersListResponse.d.ts +1 -1
- package/dist/types/sdk/generated/ts-client/api/types/Agent.d.ts +16 -5
- package/dist/types/sdk/generated/ts-client/api/types/AgentProviderOption.d.ts +11 -0
- package/dist/types/sdk/generated/ts-client/api/types/AgentPublic.d.ts +6 -1
- package/dist/types/sdk/generated/ts-client/api/types/ChatDeleted.d.ts +15 -0
- package/dist/types/sdk/generated/ts-client/api/types/ChatSelection.d.ts +2 -0
- package/dist/types/sdk/generated/ts-client/api/types/EventsFailure.d.ts +2 -2
- package/dist/types/sdk/generated/ts-client/api/types/EventsInboxState.d.ts +1 -0
- package/dist/types/sdk/generated/ts-client/api/types/ModelInfo.d.ts +6 -0
- package/dist/types/sdk/generated/ts-client/api/types/MyProviderStatus.d.ts +61 -0
- package/dist/types/sdk/generated/ts-client/api/types/index.d.ts +3 -0
- package/dist/types/sdk/generated/ts-client/environments.d.ts +1 -1
- package/dist/types/sdk/ts/client/src/index.d.ts +2 -1
- package/dist/types/sdk/ts/core-live/src/client.d.ts +1 -1
- package/package.json +3 -2
- package/dist/chunk-X24QQ3X4.js.map +0 -7
|
@@ -369,6 +369,15 @@ var Chat;
|
|
|
369
369
|
};
|
|
370
370
|
})(Chat || (Chat = {}));
|
|
371
371
|
|
|
372
|
+
// ../../generated/ts-client/api/types/ChatDeleted.ts
|
|
373
|
+
var ChatDeleted;
|
|
374
|
+
((ChatDeleted2) => {
|
|
375
|
+
ChatDeleted2.Cleanup = {
|
|
376
|
+
Pending: "pending",
|
|
377
|
+
Done: "done"
|
|
378
|
+
};
|
|
379
|
+
})(ChatDeleted || (ChatDeleted = {}));
|
|
380
|
+
|
|
372
381
|
// ../../generated/ts-client/api/types/ChatSelection.ts
|
|
373
382
|
var ChatSelection;
|
|
374
383
|
((ChatSelection2) => {
|
|
@@ -594,7 +603,8 @@ var EventsInboxState;
|
|
|
594
603
|
Limit: "limit",
|
|
595
604
|
NoCredit: "no_credit",
|
|
596
605
|
Auth: "auth",
|
|
597
|
-
Error: "error"
|
|
606
|
+
Error: "error",
|
|
607
|
+
WakeFailed: "wake_failed"
|
|
598
608
|
};
|
|
599
609
|
})(Held = EventsInboxState2.Held || (EventsInboxState2.Held = {}));
|
|
600
610
|
})(EventsInboxState || (EventsInboxState = {}));
|
|
@@ -1096,6 +1106,33 @@ var Machine;
|
|
|
1096
1106
|
};
|
|
1097
1107
|
})(Machine || (Machine = {}));
|
|
1098
1108
|
|
|
1109
|
+
// ../../generated/ts-client/api/types/MyProviderStatus.ts
|
|
1110
|
+
var MyProviderStatus;
|
|
1111
|
+
((MyProviderStatus2) => {
|
|
1112
|
+
let Via;
|
|
1113
|
+
((Via2) => {
|
|
1114
|
+
Via2.Item = {
|
|
1115
|
+
Subscription: "subscription",
|
|
1116
|
+
Key: "key",
|
|
1117
|
+
Agent: "agent"
|
|
1118
|
+
};
|
|
1119
|
+
})(Via = MyProviderStatus2.Via || (MyProviderStatus2.Via = {}));
|
|
1120
|
+
MyProviderStatus2.Status = {
|
|
1121
|
+
Ok: "ok",
|
|
1122
|
+
Expiring: "expiring",
|
|
1123
|
+
Dead: "dead",
|
|
1124
|
+
Disconnected: "disconnected"
|
|
1125
|
+
};
|
|
1126
|
+
let Connect;
|
|
1127
|
+
((Connect2) => {
|
|
1128
|
+
Connect2.Item = {
|
|
1129
|
+
Oauth: "oauth",
|
|
1130
|
+
Device: "device",
|
|
1131
|
+
Key: "key"
|
|
1132
|
+
};
|
|
1133
|
+
})(Connect = MyProviderStatus2.Connect || (MyProviderStatus2.Connect = {}));
|
|
1134
|
+
})(MyProviderStatus || (MyProviderStatus = {}));
|
|
1135
|
+
|
|
1099
1136
|
// ../../generated/ts-client/api/types/Pairing.ts
|
|
1100
1137
|
var Pairing;
|
|
1101
1138
|
((Pairing2) => {
|
|
@@ -3490,7 +3527,7 @@ function withNoOpAuthProvider(options) {
|
|
|
3490
3527
|
|
|
3491
3528
|
// ../../generated/ts-client/environments.ts
|
|
3492
3529
|
var SmoothAgentApiEnvironment = {
|
|
3493
|
-
Default: "https://api.
|
|
3530
|
+
Default: "https://smoothagent-v3-api.uaibuilder.workers.dev/v3"
|
|
3494
3531
|
};
|
|
3495
3532
|
|
|
3496
3533
|
// ../../generated/ts-client/errors/handleNonStatusCodeError.ts
|
|
@@ -3736,23 +3773,35 @@ var AgentsClient = class {
|
|
|
3736
3773
|
if (_response.error.reason === "status-code") {
|
|
3737
3774
|
switch (_response.error.statusCode) {
|
|
3738
3775
|
case 400:
|
|
3739
|
-
throw new BadRequestError(
|
|
3776
|
+
throw new BadRequestError(
|
|
3777
|
+
_response.error.body,
|
|
3778
|
+
_response.rawResponse
|
|
3779
|
+
);
|
|
3740
3780
|
case 401:
|
|
3741
|
-
throw new UnauthorizedError(
|
|
3781
|
+
throw new UnauthorizedError(
|
|
3782
|
+
_response.error.body,
|
|
3783
|
+
_response.rawResponse
|
|
3784
|
+
);
|
|
3742
3785
|
case 402:
|
|
3743
3786
|
throw new PaymentRequiredError(
|
|
3744
3787
|
_response.error.body,
|
|
3745
3788
|
_response.rawResponse
|
|
3746
3789
|
);
|
|
3747
3790
|
case 403:
|
|
3748
|
-
throw new ForbiddenError(
|
|
3791
|
+
throw new ForbiddenError(
|
|
3792
|
+
_response.error.body,
|
|
3793
|
+
_response.rawResponse
|
|
3794
|
+
);
|
|
3749
3795
|
case 404:
|
|
3750
3796
|
throw new NotFoundError(
|
|
3751
3797
|
_response.error.body,
|
|
3752
3798
|
_response.rawResponse
|
|
3753
3799
|
);
|
|
3754
3800
|
case 409:
|
|
3755
|
-
throw new ConflictError(
|
|
3801
|
+
throw new ConflictError(
|
|
3802
|
+
_response.error.body,
|
|
3803
|
+
_response.rawResponse
|
|
3804
|
+
);
|
|
3756
3805
|
case 410:
|
|
3757
3806
|
throw new GoneError(
|
|
3758
3807
|
_response.error.body,
|
|
@@ -4052,23 +4101,35 @@ var ChatsClient = class {
|
|
|
4052
4101
|
if (_response.error.reason === "status-code") {
|
|
4053
4102
|
switch (_response.error.statusCode) {
|
|
4054
4103
|
case 400:
|
|
4055
|
-
throw new BadRequestError(
|
|
4104
|
+
throw new BadRequestError(
|
|
4105
|
+
_response.error.body,
|
|
4106
|
+
_response.rawResponse
|
|
4107
|
+
);
|
|
4056
4108
|
case 401:
|
|
4057
|
-
throw new UnauthorizedError(
|
|
4109
|
+
throw new UnauthorizedError(
|
|
4110
|
+
_response.error.body,
|
|
4111
|
+
_response.rawResponse
|
|
4112
|
+
);
|
|
4058
4113
|
case 402:
|
|
4059
4114
|
throw new PaymentRequiredError(
|
|
4060
4115
|
_response.error.body,
|
|
4061
4116
|
_response.rawResponse
|
|
4062
4117
|
);
|
|
4063
4118
|
case 403:
|
|
4064
|
-
throw new ForbiddenError(
|
|
4119
|
+
throw new ForbiddenError(
|
|
4120
|
+
_response.error.body,
|
|
4121
|
+
_response.rawResponse
|
|
4122
|
+
);
|
|
4065
4123
|
case 404:
|
|
4066
4124
|
throw new NotFoundError(
|
|
4067
4125
|
_response.error.body,
|
|
4068
4126
|
_response.rawResponse
|
|
4069
4127
|
);
|
|
4070
4128
|
case 409:
|
|
4071
|
-
throw new ConflictError(
|
|
4129
|
+
throw new ConflictError(
|
|
4130
|
+
_response.error.body,
|
|
4131
|
+
_response.rawResponse
|
|
4132
|
+
);
|
|
4072
4133
|
case 410:
|
|
4073
4134
|
throw new GoneError(
|
|
4074
4135
|
_response.error.body,
|
|
@@ -4171,23 +4232,35 @@ var ChatsClient = class {
|
|
|
4171
4232
|
if (_response.error.reason === "status-code") {
|
|
4172
4233
|
switch (_response.error.statusCode) {
|
|
4173
4234
|
case 400:
|
|
4174
|
-
throw new BadRequestError(
|
|
4235
|
+
throw new BadRequestError(
|
|
4236
|
+
_response.error.body,
|
|
4237
|
+
_response.rawResponse
|
|
4238
|
+
);
|
|
4175
4239
|
case 401:
|
|
4176
|
-
throw new UnauthorizedError(
|
|
4240
|
+
throw new UnauthorizedError(
|
|
4241
|
+
_response.error.body,
|
|
4242
|
+
_response.rawResponse
|
|
4243
|
+
);
|
|
4177
4244
|
case 402:
|
|
4178
4245
|
throw new PaymentRequiredError(
|
|
4179
4246
|
_response.error.body,
|
|
4180
4247
|
_response.rawResponse
|
|
4181
4248
|
);
|
|
4182
4249
|
case 403:
|
|
4183
|
-
throw new ForbiddenError(
|
|
4250
|
+
throw new ForbiddenError(
|
|
4251
|
+
_response.error.body,
|
|
4252
|
+
_response.rawResponse
|
|
4253
|
+
);
|
|
4184
4254
|
case 404:
|
|
4185
4255
|
throw new NotFoundError(
|
|
4186
4256
|
_response.error.body,
|
|
4187
4257
|
_response.rawResponse
|
|
4188
4258
|
);
|
|
4189
4259
|
case 409:
|
|
4190
|
-
throw new ConflictError(
|
|
4260
|
+
throw new ConflictError(
|
|
4261
|
+
_response.error.body,
|
|
4262
|
+
_response.rawResponse
|
|
4263
|
+
);
|
|
4191
4264
|
case 410:
|
|
4192
4265
|
throw new GoneError(
|
|
4193
4266
|
_response.error.body,
|
|
@@ -4234,7 +4307,8 @@ var ChatsClient = class {
|
|
|
4234
4307
|
return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/chats/{id}");
|
|
4235
4308
|
}
|
|
4236
4309
|
/**
|
|
4237
|
-
* Apaga o chat, o log e a box própria (a instância só é destruída aqui).
|
|
4310
|
+
* Apaga o chat, o log e a box própria (a instância só é destruída aqui).O chat some NA HORA (404 em toda rota, inclusive o `/live`; o socket aberto recebe `bye`). A limpeza da box própria
|
|
4311
|
+
* (Detona) segue em segundo plano — `cleanup: pending` — e um cron repete até destruir (com teto e alerta).
|
|
4238
4312
|
*
|
|
4239
4313
|
* @param {SmoothAgentApi.ChatsDeleteRequest} request
|
|
4240
4314
|
* @param {ChatsClient.RequestOptions} requestOptions - Request-specific configuration.
|
|
@@ -4292,23 +4366,35 @@ var ChatsClient = class {
|
|
|
4292
4366
|
if (_response.error.reason === "status-code") {
|
|
4293
4367
|
switch (_response.error.statusCode) {
|
|
4294
4368
|
case 400:
|
|
4295
|
-
throw new BadRequestError(
|
|
4369
|
+
throw new BadRequestError(
|
|
4370
|
+
_response.error.body,
|
|
4371
|
+
_response.rawResponse
|
|
4372
|
+
);
|
|
4296
4373
|
case 401:
|
|
4297
|
-
throw new UnauthorizedError(
|
|
4374
|
+
throw new UnauthorizedError(
|
|
4375
|
+
_response.error.body,
|
|
4376
|
+
_response.rawResponse
|
|
4377
|
+
);
|
|
4298
4378
|
case 402:
|
|
4299
4379
|
throw new PaymentRequiredError(
|
|
4300
4380
|
_response.error.body,
|
|
4301
4381
|
_response.rawResponse
|
|
4302
4382
|
);
|
|
4303
4383
|
case 403:
|
|
4304
|
-
throw new ForbiddenError(
|
|
4384
|
+
throw new ForbiddenError(
|
|
4385
|
+
_response.error.body,
|
|
4386
|
+
_response.rawResponse
|
|
4387
|
+
);
|
|
4305
4388
|
case 404:
|
|
4306
4389
|
throw new NotFoundError(
|
|
4307
4390
|
_response.error.body,
|
|
4308
4391
|
_response.rawResponse
|
|
4309
4392
|
);
|
|
4310
4393
|
case 409:
|
|
4311
|
-
throw new ConflictError(
|
|
4394
|
+
throw new ConflictError(
|
|
4395
|
+
_response.error.body,
|
|
4396
|
+
_response.rawResponse
|
|
4397
|
+
);
|
|
4312
4398
|
case 410:
|
|
4313
4399
|
throw new GoneError(
|
|
4314
4400
|
_response.error.body,
|
|
@@ -4414,23 +4500,35 @@ var ChatsClient = class {
|
|
|
4414
4500
|
if (_response.error.reason === "status-code") {
|
|
4415
4501
|
switch (_response.error.statusCode) {
|
|
4416
4502
|
case 400:
|
|
4417
|
-
throw new BadRequestError(
|
|
4503
|
+
throw new BadRequestError(
|
|
4504
|
+
_response.error.body,
|
|
4505
|
+
_response.rawResponse
|
|
4506
|
+
);
|
|
4418
4507
|
case 401:
|
|
4419
|
-
throw new UnauthorizedError(
|
|
4508
|
+
throw new UnauthorizedError(
|
|
4509
|
+
_response.error.body,
|
|
4510
|
+
_response.rawResponse
|
|
4511
|
+
);
|
|
4420
4512
|
case 402:
|
|
4421
4513
|
throw new PaymentRequiredError(
|
|
4422
4514
|
_response.error.body,
|
|
4423
4515
|
_response.rawResponse
|
|
4424
4516
|
);
|
|
4425
4517
|
case 403:
|
|
4426
|
-
throw new ForbiddenError(
|
|
4518
|
+
throw new ForbiddenError(
|
|
4519
|
+
_response.error.body,
|
|
4520
|
+
_response.rawResponse
|
|
4521
|
+
);
|
|
4427
4522
|
case 404:
|
|
4428
4523
|
throw new NotFoundError(
|
|
4429
4524
|
_response.error.body,
|
|
4430
4525
|
_response.rawResponse
|
|
4431
4526
|
);
|
|
4432
4527
|
case 409:
|
|
4433
|
-
throw new ConflictError(
|
|
4528
|
+
throw new ConflictError(
|
|
4529
|
+
_response.error.body,
|
|
4530
|
+
_response.rawResponse
|
|
4531
|
+
);
|
|
4434
4532
|
case 410:
|
|
4435
4533
|
throw new GoneError(
|
|
4436
4534
|
_response.error.body,
|
|
@@ -4542,23 +4640,35 @@ var ChatsClient = class {
|
|
|
4542
4640
|
if (_response.error.reason === "status-code") {
|
|
4543
4641
|
switch (_response.error.statusCode) {
|
|
4544
4642
|
case 400:
|
|
4545
|
-
throw new BadRequestError(
|
|
4643
|
+
throw new BadRequestError(
|
|
4644
|
+
_response.error.body,
|
|
4645
|
+
_response.rawResponse
|
|
4646
|
+
);
|
|
4546
4647
|
case 401:
|
|
4547
|
-
throw new UnauthorizedError(
|
|
4648
|
+
throw new UnauthorizedError(
|
|
4649
|
+
_response.error.body,
|
|
4650
|
+
_response.rawResponse
|
|
4651
|
+
);
|
|
4548
4652
|
case 402:
|
|
4549
4653
|
throw new PaymentRequiredError(
|
|
4550
4654
|
_response.error.body,
|
|
4551
4655
|
_response.rawResponse
|
|
4552
4656
|
);
|
|
4553
4657
|
case 403:
|
|
4554
|
-
throw new ForbiddenError(
|
|
4658
|
+
throw new ForbiddenError(
|
|
4659
|
+
_response.error.body,
|
|
4660
|
+
_response.rawResponse
|
|
4661
|
+
);
|
|
4555
4662
|
case 404:
|
|
4556
4663
|
throw new NotFoundError(
|
|
4557
4664
|
_response.error.body,
|
|
4558
4665
|
_response.rawResponse
|
|
4559
4666
|
);
|
|
4560
4667
|
case 409:
|
|
4561
|
-
throw new ConflictError(
|
|
4668
|
+
throw new ConflictError(
|
|
4669
|
+
_response.error.body,
|
|
4670
|
+
_response.rawResponse
|
|
4671
|
+
);
|
|
4562
4672
|
case 410:
|
|
4563
4673
|
throw new GoneError(
|
|
4564
4674
|
_response.error.body,
|
|
@@ -4668,23 +4778,35 @@ var ChatsClient = class {
|
|
|
4668
4778
|
if (_response.error.reason === "status-code") {
|
|
4669
4779
|
switch (_response.error.statusCode) {
|
|
4670
4780
|
case 400:
|
|
4671
|
-
throw new BadRequestError(
|
|
4781
|
+
throw new BadRequestError(
|
|
4782
|
+
_response.error.body,
|
|
4783
|
+
_response.rawResponse
|
|
4784
|
+
);
|
|
4672
4785
|
case 401:
|
|
4673
|
-
throw new UnauthorizedError(
|
|
4786
|
+
throw new UnauthorizedError(
|
|
4787
|
+
_response.error.body,
|
|
4788
|
+
_response.rawResponse
|
|
4789
|
+
);
|
|
4674
4790
|
case 402:
|
|
4675
4791
|
throw new PaymentRequiredError(
|
|
4676
4792
|
_response.error.body,
|
|
4677
4793
|
_response.rawResponse
|
|
4678
4794
|
);
|
|
4679
4795
|
case 403:
|
|
4680
|
-
throw new ForbiddenError(
|
|
4796
|
+
throw new ForbiddenError(
|
|
4797
|
+
_response.error.body,
|
|
4798
|
+
_response.rawResponse
|
|
4799
|
+
);
|
|
4681
4800
|
case 404:
|
|
4682
4801
|
throw new NotFoundError(
|
|
4683
4802
|
_response.error.body,
|
|
4684
4803
|
_response.rawResponse
|
|
4685
4804
|
);
|
|
4686
4805
|
case 409:
|
|
4687
|
-
throw new ConflictError(
|
|
4806
|
+
throw new ConflictError(
|
|
4807
|
+
_response.error.body,
|
|
4808
|
+
_response.rawResponse
|
|
4809
|
+
);
|
|
4688
4810
|
case 410:
|
|
4689
4811
|
throw new GoneError(
|
|
4690
4812
|
_response.error.body,
|
|
@@ -4792,23 +4914,35 @@ var ChatsClient = class {
|
|
|
4792
4914
|
if (_response.error.reason === "status-code") {
|
|
4793
4915
|
switch (_response.error.statusCode) {
|
|
4794
4916
|
case 400:
|
|
4795
|
-
throw new BadRequestError(
|
|
4917
|
+
throw new BadRequestError(
|
|
4918
|
+
_response.error.body,
|
|
4919
|
+
_response.rawResponse
|
|
4920
|
+
);
|
|
4796
4921
|
case 401:
|
|
4797
|
-
throw new UnauthorizedError(
|
|
4922
|
+
throw new UnauthorizedError(
|
|
4923
|
+
_response.error.body,
|
|
4924
|
+
_response.rawResponse
|
|
4925
|
+
);
|
|
4798
4926
|
case 402:
|
|
4799
4927
|
throw new PaymentRequiredError(
|
|
4800
4928
|
_response.error.body,
|
|
4801
4929
|
_response.rawResponse
|
|
4802
4930
|
);
|
|
4803
4931
|
case 403:
|
|
4804
|
-
throw new ForbiddenError(
|
|
4932
|
+
throw new ForbiddenError(
|
|
4933
|
+
_response.error.body,
|
|
4934
|
+
_response.rawResponse
|
|
4935
|
+
);
|
|
4805
4936
|
case 404:
|
|
4806
4937
|
throw new NotFoundError(
|
|
4807
4938
|
_response.error.body,
|
|
4808
4939
|
_response.rawResponse
|
|
4809
4940
|
);
|
|
4810
4941
|
case 409:
|
|
4811
|
-
throw new ConflictError(
|
|
4942
|
+
throw new ConflictError(
|
|
4943
|
+
_response.error.body,
|
|
4944
|
+
_response.rawResponse
|
|
4945
|
+
);
|
|
4812
4946
|
case 410:
|
|
4813
4947
|
throw new GoneError(
|
|
4814
4948
|
_response.error.body,
|
|
@@ -4903,23 +5037,35 @@ var ChatsClient = class {
|
|
|
4903
5037
|
if (_response.error.reason === "status-code") {
|
|
4904
5038
|
switch (_response.error.statusCode) {
|
|
4905
5039
|
case 400:
|
|
4906
|
-
throw new BadRequestError(
|
|
5040
|
+
throw new BadRequestError(
|
|
5041
|
+
_response.error.body,
|
|
5042
|
+
_response.rawResponse
|
|
5043
|
+
);
|
|
4907
5044
|
case 401:
|
|
4908
|
-
throw new UnauthorizedError(
|
|
5045
|
+
throw new UnauthorizedError(
|
|
5046
|
+
_response.error.body,
|
|
5047
|
+
_response.rawResponse
|
|
5048
|
+
);
|
|
4909
5049
|
case 402:
|
|
4910
5050
|
throw new PaymentRequiredError(
|
|
4911
5051
|
_response.error.body,
|
|
4912
5052
|
_response.rawResponse
|
|
4913
5053
|
);
|
|
4914
5054
|
case 403:
|
|
4915
|
-
throw new ForbiddenError(
|
|
5055
|
+
throw new ForbiddenError(
|
|
5056
|
+
_response.error.body,
|
|
5057
|
+
_response.rawResponse
|
|
5058
|
+
);
|
|
4916
5059
|
case 404:
|
|
4917
5060
|
throw new NotFoundError(
|
|
4918
5061
|
_response.error.body,
|
|
4919
5062
|
_response.rawResponse
|
|
4920
5063
|
);
|
|
4921
5064
|
case 409:
|
|
4922
|
-
throw new ConflictError(
|
|
5065
|
+
throw new ConflictError(
|
|
5066
|
+
_response.error.body,
|
|
5067
|
+
_response.rawResponse
|
|
5068
|
+
);
|
|
4923
5069
|
case 410:
|
|
4924
5070
|
throw new GoneError(
|
|
4925
5071
|
_response.error.body,
|
|
@@ -5030,23 +5176,35 @@ var ChatsClient = class {
|
|
|
5030
5176
|
if (_response.error.reason === "status-code") {
|
|
5031
5177
|
switch (_response.error.statusCode) {
|
|
5032
5178
|
case 400:
|
|
5033
|
-
throw new BadRequestError(
|
|
5179
|
+
throw new BadRequestError(
|
|
5180
|
+
_response.error.body,
|
|
5181
|
+
_response.rawResponse
|
|
5182
|
+
);
|
|
5034
5183
|
case 401:
|
|
5035
|
-
throw new UnauthorizedError(
|
|
5184
|
+
throw new UnauthorizedError(
|
|
5185
|
+
_response.error.body,
|
|
5186
|
+
_response.rawResponse
|
|
5187
|
+
);
|
|
5036
5188
|
case 402:
|
|
5037
5189
|
throw new PaymentRequiredError(
|
|
5038
5190
|
_response.error.body,
|
|
5039
5191
|
_response.rawResponse
|
|
5040
5192
|
);
|
|
5041
5193
|
case 403:
|
|
5042
|
-
throw new ForbiddenError(
|
|
5194
|
+
throw new ForbiddenError(
|
|
5195
|
+
_response.error.body,
|
|
5196
|
+
_response.rawResponse
|
|
5197
|
+
);
|
|
5043
5198
|
case 404:
|
|
5044
5199
|
throw new NotFoundError(
|
|
5045
5200
|
_response.error.body,
|
|
5046
5201
|
_response.rawResponse
|
|
5047
5202
|
);
|
|
5048
5203
|
case 409:
|
|
5049
|
-
throw new ConflictError(
|
|
5204
|
+
throw new ConflictError(
|
|
5205
|
+
_response.error.body,
|
|
5206
|
+
_response.rawResponse
|
|
5207
|
+
);
|
|
5050
5208
|
case 410:
|
|
5051
5209
|
throw new GoneError(
|
|
5052
5210
|
_response.error.body,
|
|
@@ -5154,23 +5312,35 @@ var ChatsClient = class {
|
|
|
5154
5312
|
if (_response.error.reason === "status-code") {
|
|
5155
5313
|
switch (_response.error.statusCode) {
|
|
5156
5314
|
case 400:
|
|
5157
|
-
throw new BadRequestError(
|
|
5315
|
+
throw new BadRequestError(
|
|
5316
|
+
_response.error.body,
|
|
5317
|
+
_response.rawResponse
|
|
5318
|
+
);
|
|
5158
5319
|
case 401:
|
|
5159
|
-
throw new UnauthorizedError(
|
|
5320
|
+
throw new UnauthorizedError(
|
|
5321
|
+
_response.error.body,
|
|
5322
|
+
_response.rawResponse
|
|
5323
|
+
);
|
|
5160
5324
|
case 402:
|
|
5161
5325
|
throw new PaymentRequiredError(
|
|
5162
5326
|
_response.error.body,
|
|
5163
5327
|
_response.rawResponse
|
|
5164
5328
|
);
|
|
5165
5329
|
case 403:
|
|
5166
|
-
throw new ForbiddenError(
|
|
5330
|
+
throw new ForbiddenError(
|
|
5331
|
+
_response.error.body,
|
|
5332
|
+
_response.rawResponse
|
|
5333
|
+
);
|
|
5167
5334
|
case 404:
|
|
5168
5335
|
throw new NotFoundError(
|
|
5169
5336
|
_response.error.body,
|
|
5170
5337
|
_response.rawResponse
|
|
5171
5338
|
);
|
|
5172
5339
|
case 409:
|
|
5173
|
-
throw new ConflictError(
|
|
5340
|
+
throw new ConflictError(
|
|
5341
|
+
_response.error.body,
|
|
5342
|
+
_response.rawResponse
|
|
5343
|
+
);
|
|
5174
5344
|
case 410:
|
|
5175
5345
|
throw new GoneError(
|
|
5176
5346
|
_response.error.body,
|
|
@@ -5277,23 +5447,35 @@ var ChatsClient = class {
|
|
|
5277
5447
|
if (_response.error.reason === "status-code") {
|
|
5278
5448
|
switch (_response.error.statusCode) {
|
|
5279
5449
|
case 400:
|
|
5280
|
-
throw new BadRequestError(
|
|
5450
|
+
throw new BadRequestError(
|
|
5451
|
+
_response.error.body,
|
|
5452
|
+
_response.rawResponse
|
|
5453
|
+
);
|
|
5281
5454
|
case 401:
|
|
5282
|
-
throw new UnauthorizedError(
|
|
5455
|
+
throw new UnauthorizedError(
|
|
5456
|
+
_response.error.body,
|
|
5457
|
+
_response.rawResponse
|
|
5458
|
+
);
|
|
5283
5459
|
case 402:
|
|
5284
5460
|
throw new PaymentRequiredError(
|
|
5285
5461
|
_response.error.body,
|
|
5286
5462
|
_response.rawResponse
|
|
5287
5463
|
);
|
|
5288
5464
|
case 403:
|
|
5289
|
-
throw new ForbiddenError(
|
|
5465
|
+
throw new ForbiddenError(
|
|
5466
|
+
_response.error.body,
|
|
5467
|
+
_response.rawResponse
|
|
5468
|
+
);
|
|
5290
5469
|
case 404:
|
|
5291
5470
|
throw new NotFoundError(
|
|
5292
5471
|
_response.error.body,
|
|
5293
5472
|
_response.rawResponse
|
|
5294
5473
|
);
|
|
5295
5474
|
case 409:
|
|
5296
|
-
throw new ConflictError(
|
|
5475
|
+
throw new ConflictError(
|
|
5476
|
+
_response.error.body,
|
|
5477
|
+
_response.rawResponse
|
|
5478
|
+
);
|
|
5297
5479
|
case 410:
|
|
5298
5480
|
throw new GoneError(
|
|
5299
5481
|
_response.error.body,
|
|
@@ -5408,23 +5590,35 @@ var ChatsClient = class {
|
|
|
5408
5590
|
if (_response.error.reason === "status-code") {
|
|
5409
5591
|
switch (_response.error.statusCode) {
|
|
5410
5592
|
case 400:
|
|
5411
|
-
throw new BadRequestError(
|
|
5593
|
+
throw new BadRequestError(
|
|
5594
|
+
_response.error.body,
|
|
5595
|
+
_response.rawResponse
|
|
5596
|
+
);
|
|
5412
5597
|
case 401:
|
|
5413
|
-
throw new UnauthorizedError(
|
|
5598
|
+
throw new UnauthorizedError(
|
|
5599
|
+
_response.error.body,
|
|
5600
|
+
_response.rawResponse
|
|
5601
|
+
);
|
|
5414
5602
|
case 402:
|
|
5415
5603
|
throw new PaymentRequiredError(
|
|
5416
5604
|
_response.error.body,
|
|
5417
5605
|
_response.rawResponse
|
|
5418
5606
|
);
|
|
5419
5607
|
case 403:
|
|
5420
|
-
throw new ForbiddenError(
|
|
5608
|
+
throw new ForbiddenError(
|
|
5609
|
+
_response.error.body,
|
|
5610
|
+
_response.rawResponse
|
|
5611
|
+
);
|
|
5421
5612
|
case 404:
|
|
5422
5613
|
throw new NotFoundError(
|
|
5423
5614
|
_response.error.body,
|
|
5424
5615
|
_response.rawResponse
|
|
5425
5616
|
);
|
|
5426
5617
|
case 409:
|
|
5427
|
-
throw new ConflictError(
|
|
5618
|
+
throw new ConflictError(
|
|
5619
|
+
_response.error.body,
|
|
5620
|
+
_response.rawResponse
|
|
5621
|
+
);
|
|
5428
5622
|
case 410:
|
|
5429
5623
|
throw new GoneError(
|
|
5430
5624
|
_response.error.body,
|
|
@@ -5530,23 +5724,35 @@ var ChatsClient = class {
|
|
|
5530
5724
|
if (_response.error.reason === "status-code") {
|
|
5531
5725
|
switch (_response.error.statusCode) {
|
|
5532
5726
|
case 400:
|
|
5533
|
-
throw new BadRequestError(
|
|
5727
|
+
throw new BadRequestError(
|
|
5728
|
+
_response.error.body,
|
|
5729
|
+
_response.rawResponse
|
|
5730
|
+
);
|
|
5534
5731
|
case 401:
|
|
5535
|
-
throw new UnauthorizedError(
|
|
5732
|
+
throw new UnauthorizedError(
|
|
5733
|
+
_response.error.body,
|
|
5734
|
+
_response.rawResponse
|
|
5735
|
+
);
|
|
5536
5736
|
case 402:
|
|
5537
5737
|
throw new PaymentRequiredError(
|
|
5538
5738
|
_response.error.body,
|
|
5539
5739
|
_response.rawResponse
|
|
5540
5740
|
);
|
|
5541
5741
|
case 403:
|
|
5542
|
-
throw new ForbiddenError(
|
|
5742
|
+
throw new ForbiddenError(
|
|
5743
|
+
_response.error.body,
|
|
5744
|
+
_response.rawResponse
|
|
5745
|
+
);
|
|
5543
5746
|
case 404:
|
|
5544
5747
|
throw new NotFoundError(
|
|
5545
5748
|
_response.error.body,
|
|
5546
5749
|
_response.rawResponse
|
|
5547
5750
|
);
|
|
5548
5751
|
case 409:
|
|
5549
|
-
throw new ConflictError(
|
|
5752
|
+
throw new ConflictError(
|
|
5753
|
+
_response.error.body,
|
|
5754
|
+
_response.rawResponse
|
|
5755
|
+
);
|
|
5550
5756
|
case 410:
|
|
5551
5757
|
throw new GoneError(
|
|
5552
5758
|
_response.error.body,
|
|
@@ -5655,23 +5861,35 @@ var ChatsClient = class {
|
|
|
5655
5861
|
if (_response.error.reason === "status-code") {
|
|
5656
5862
|
switch (_response.error.statusCode) {
|
|
5657
5863
|
case 400:
|
|
5658
|
-
throw new BadRequestError(
|
|
5864
|
+
throw new BadRequestError(
|
|
5865
|
+
_response.error.body,
|
|
5866
|
+
_response.rawResponse
|
|
5867
|
+
);
|
|
5659
5868
|
case 401:
|
|
5660
|
-
throw new UnauthorizedError(
|
|
5869
|
+
throw new UnauthorizedError(
|
|
5870
|
+
_response.error.body,
|
|
5871
|
+
_response.rawResponse
|
|
5872
|
+
);
|
|
5661
5873
|
case 402:
|
|
5662
5874
|
throw new PaymentRequiredError(
|
|
5663
5875
|
_response.error.body,
|
|
5664
5876
|
_response.rawResponse
|
|
5665
5877
|
);
|
|
5666
5878
|
case 403:
|
|
5667
|
-
throw new ForbiddenError(
|
|
5879
|
+
throw new ForbiddenError(
|
|
5880
|
+
_response.error.body,
|
|
5881
|
+
_response.rawResponse
|
|
5882
|
+
);
|
|
5668
5883
|
case 404:
|
|
5669
5884
|
throw new NotFoundError(
|
|
5670
5885
|
_response.error.body,
|
|
5671
5886
|
_response.rawResponse
|
|
5672
5887
|
);
|
|
5673
5888
|
case 409:
|
|
5674
|
-
throw new ConflictError(
|
|
5889
|
+
throw new ConflictError(
|
|
5890
|
+
_response.error.body,
|
|
5891
|
+
_response.rawResponse
|
|
5892
|
+
);
|
|
5675
5893
|
case 410:
|
|
5676
5894
|
throw new GoneError(
|
|
5677
5895
|
_response.error.body,
|
|
@@ -5777,23 +5995,35 @@ var ChatsClient = class {
|
|
|
5777
5995
|
if (_response.error.reason === "status-code") {
|
|
5778
5996
|
switch (_response.error.statusCode) {
|
|
5779
5997
|
case 400:
|
|
5780
|
-
throw new BadRequestError(
|
|
5998
|
+
throw new BadRequestError(
|
|
5999
|
+
_response.error.body,
|
|
6000
|
+
_response.rawResponse
|
|
6001
|
+
);
|
|
5781
6002
|
case 401:
|
|
5782
|
-
throw new UnauthorizedError(
|
|
6003
|
+
throw new UnauthorizedError(
|
|
6004
|
+
_response.error.body,
|
|
6005
|
+
_response.rawResponse
|
|
6006
|
+
);
|
|
5783
6007
|
case 402:
|
|
5784
6008
|
throw new PaymentRequiredError(
|
|
5785
6009
|
_response.error.body,
|
|
5786
6010
|
_response.rawResponse
|
|
5787
6011
|
);
|
|
5788
6012
|
case 403:
|
|
5789
|
-
throw new ForbiddenError(
|
|
6013
|
+
throw new ForbiddenError(
|
|
6014
|
+
_response.error.body,
|
|
6015
|
+
_response.rawResponse
|
|
6016
|
+
);
|
|
5790
6017
|
case 404:
|
|
5791
6018
|
throw new NotFoundError(
|
|
5792
6019
|
_response.error.body,
|
|
5793
6020
|
_response.rawResponse
|
|
5794
6021
|
);
|
|
5795
6022
|
case 409:
|
|
5796
|
-
throw new ConflictError(
|
|
6023
|
+
throw new ConflictError(
|
|
6024
|
+
_response.error.body,
|
|
6025
|
+
_response.rawResponse
|
|
6026
|
+
);
|
|
5797
6027
|
case 410:
|
|
5798
6028
|
throw new GoneError(
|
|
5799
6029
|
_response.error.body,
|
|
@@ -5903,23 +6133,35 @@ var ChatsClient = class {
|
|
|
5903
6133
|
if (_response.error.reason === "status-code") {
|
|
5904
6134
|
switch (_response.error.statusCode) {
|
|
5905
6135
|
case 400:
|
|
5906
|
-
throw new BadRequestError(
|
|
6136
|
+
throw new BadRequestError(
|
|
6137
|
+
_response.error.body,
|
|
6138
|
+
_response.rawResponse
|
|
6139
|
+
);
|
|
5907
6140
|
case 401:
|
|
5908
|
-
throw new UnauthorizedError(
|
|
6141
|
+
throw new UnauthorizedError(
|
|
6142
|
+
_response.error.body,
|
|
6143
|
+
_response.rawResponse
|
|
6144
|
+
);
|
|
5909
6145
|
case 402:
|
|
5910
6146
|
throw new PaymentRequiredError(
|
|
5911
6147
|
_response.error.body,
|
|
5912
6148
|
_response.rawResponse
|
|
5913
6149
|
);
|
|
5914
6150
|
case 403:
|
|
5915
|
-
throw new ForbiddenError(
|
|
6151
|
+
throw new ForbiddenError(
|
|
6152
|
+
_response.error.body,
|
|
6153
|
+
_response.rawResponse
|
|
6154
|
+
);
|
|
5916
6155
|
case 404:
|
|
5917
6156
|
throw new NotFoundError(
|
|
5918
6157
|
_response.error.body,
|
|
5919
6158
|
_response.rawResponse
|
|
5920
6159
|
);
|
|
5921
6160
|
case 409:
|
|
5922
|
-
throw new ConflictError(
|
|
6161
|
+
throw new ConflictError(
|
|
6162
|
+
_response.error.body,
|
|
6163
|
+
_response.rawResponse
|
|
6164
|
+
);
|
|
5923
6165
|
case 410:
|
|
5924
6166
|
throw new GoneError(
|
|
5925
6167
|
_response.error.body,
|
|
@@ -6027,23 +6269,35 @@ var ChatsClient = class {
|
|
|
6027
6269
|
if (_response.error.reason === "status-code") {
|
|
6028
6270
|
switch (_response.error.statusCode) {
|
|
6029
6271
|
case 400:
|
|
6030
|
-
throw new BadRequestError(
|
|
6272
|
+
throw new BadRequestError(
|
|
6273
|
+
_response.error.body,
|
|
6274
|
+
_response.rawResponse
|
|
6275
|
+
);
|
|
6031
6276
|
case 401:
|
|
6032
|
-
throw new UnauthorizedError(
|
|
6277
|
+
throw new UnauthorizedError(
|
|
6278
|
+
_response.error.body,
|
|
6279
|
+
_response.rawResponse
|
|
6280
|
+
);
|
|
6033
6281
|
case 402:
|
|
6034
6282
|
throw new PaymentRequiredError(
|
|
6035
6283
|
_response.error.body,
|
|
6036
6284
|
_response.rawResponse
|
|
6037
6285
|
);
|
|
6038
6286
|
case 403:
|
|
6039
|
-
throw new ForbiddenError(
|
|
6287
|
+
throw new ForbiddenError(
|
|
6288
|
+
_response.error.body,
|
|
6289
|
+
_response.rawResponse
|
|
6290
|
+
);
|
|
6040
6291
|
case 404:
|
|
6041
6292
|
throw new NotFoundError(
|
|
6042
6293
|
_response.error.body,
|
|
6043
6294
|
_response.rawResponse
|
|
6044
6295
|
);
|
|
6045
6296
|
case 409:
|
|
6046
|
-
throw new ConflictError(
|
|
6297
|
+
throw new ConflictError(
|
|
6298
|
+
_response.error.body,
|
|
6299
|
+
_response.rawResponse
|
|
6300
|
+
);
|
|
6047
6301
|
case 410:
|
|
6048
6302
|
throw new GoneError(
|
|
6049
6303
|
_response.error.body,
|
|
@@ -6151,23 +6405,35 @@ var ChatsClient = class {
|
|
|
6151
6405
|
if (_response.error.reason === "status-code") {
|
|
6152
6406
|
switch (_response.error.statusCode) {
|
|
6153
6407
|
case 400:
|
|
6154
|
-
throw new BadRequestError(
|
|
6408
|
+
throw new BadRequestError(
|
|
6409
|
+
_response.error.body,
|
|
6410
|
+
_response.rawResponse
|
|
6411
|
+
);
|
|
6155
6412
|
case 401:
|
|
6156
|
-
throw new UnauthorizedError(
|
|
6413
|
+
throw new UnauthorizedError(
|
|
6414
|
+
_response.error.body,
|
|
6415
|
+
_response.rawResponse
|
|
6416
|
+
);
|
|
6157
6417
|
case 402:
|
|
6158
6418
|
throw new PaymentRequiredError(
|
|
6159
6419
|
_response.error.body,
|
|
6160
6420
|
_response.rawResponse
|
|
6161
6421
|
);
|
|
6162
6422
|
case 403:
|
|
6163
|
-
throw new ForbiddenError(
|
|
6423
|
+
throw new ForbiddenError(
|
|
6424
|
+
_response.error.body,
|
|
6425
|
+
_response.rawResponse
|
|
6426
|
+
);
|
|
6164
6427
|
case 404:
|
|
6165
6428
|
throw new NotFoundError(
|
|
6166
6429
|
_response.error.body,
|
|
6167
6430
|
_response.rawResponse
|
|
6168
6431
|
);
|
|
6169
6432
|
case 409:
|
|
6170
|
-
throw new ConflictError(
|
|
6433
|
+
throw new ConflictError(
|
|
6434
|
+
_response.error.body,
|
|
6435
|
+
_response.rawResponse
|
|
6436
|
+
);
|
|
6171
6437
|
case 410:
|
|
6172
6438
|
throw new GoneError(
|
|
6173
6439
|
_response.error.body,
|
|
@@ -6281,23 +6547,35 @@ var ChatsClient = class {
|
|
|
6281
6547
|
if (_response.error.reason === "status-code") {
|
|
6282
6548
|
switch (_response.error.statusCode) {
|
|
6283
6549
|
case 400:
|
|
6284
|
-
throw new BadRequestError(
|
|
6550
|
+
throw new BadRequestError(
|
|
6551
|
+
_response.error.body,
|
|
6552
|
+
_response.rawResponse
|
|
6553
|
+
);
|
|
6285
6554
|
case 401:
|
|
6286
|
-
throw new UnauthorizedError(
|
|
6287
|
-
|
|
6288
|
-
|
|
6555
|
+
throw new UnauthorizedError(
|
|
6556
|
+
_response.error.body,
|
|
6557
|
+
_response.rawResponse
|
|
6558
|
+
);
|
|
6559
|
+
case 402:
|
|
6560
|
+
throw new PaymentRequiredError(
|
|
6289
6561
|
_response.error.body,
|
|
6290
6562
|
_response.rawResponse
|
|
6291
6563
|
);
|
|
6292
6564
|
case 403:
|
|
6293
|
-
throw new ForbiddenError(
|
|
6565
|
+
throw new ForbiddenError(
|
|
6566
|
+
_response.error.body,
|
|
6567
|
+
_response.rawResponse
|
|
6568
|
+
);
|
|
6294
6569
|
case 404:
|
|
6295
6570
|
throw new NotFoundError(
|
|
6296
6571
|
_response.error.body,
|
|
6297
6572
|
_response.rawResponse
|
|
6298
6573
|
);
|
|
6299
6574
|
case 409:
|
|
6300
|
-
throw new ConflictError(
|
|
6575
|
+
throw new ConflictError(
|
|
6576
|
+
_response.error.body,
|
|
6577
|
+
_response.rawResponse
|
|
6578
|
+
);
|
|
6301
6579
|
case 410:
|
|
6302
6580
|
throw new GoneError(
|
|
6303
6581
|
_response.error.body,
|
|
@@ -6418,23 +6696,35 @@ var ChatsClient = class {
|
|
|
6418
6696
|
if (_response.error.reason === "status-code") {
|
|
6419
6697
|
switch (_response.error.statusCode) {
|
|
6420
6698
|
case 400:
|
|
6421
|
-
throw new BadRequestError(
|
|
6699
|
+
throw new BadRequestError(
|
|
6700
|
+
_response.error.body,
|
|
6701
|
+
_response.rawResponse
|
|
6702
|
+
);
|
|
6422
6703
|
case 401:
|
|
6423
|
-
throw new UnauthorizedError(
|
|
6704
|
+
throw new UnauthorizedError(
|
|
6705
|
+
_response.error.body,
|
|
6706
|
+
_response.rawResponse
|
|
6707
|
+
);
|
|
6424
6708
|
case 402:
|
|
6425
6709
|
throw new PaymentRequiredError(
|
|
6426
6710
|
_response.error.body,
|
|
6427
6711
|
_response.rawResponse
|
|
6428
6712
|
);
|
|
6429
6713
|
case 403:
|
|
6430
|
-
throw new ForbiddenError(
|
|
6714
|
+
throw new ForbiddenError(
|
|
6715
|
+
_response.error.body,
|
|
6716
|
+
_response.rawResponse
|
|
6717
|
+
);
|
|
6431
6718
|
case 404:
|
|
6432
6719
|
throw new NotFoundError(
|
|
6433
6720
|
_response.error.body,
|
|
6434
6721
|
_response.rawResponse
|
|
6435
6722
|
);
|
|
6436
6723
|
case 409:
|
|
6437
|
-
throw new ConflictError(
|
|
6724
|
+
throw new ConflictError(
|
|
6725
|
+
_response.error.body,
|
|
6726
|
+
_response.rawResponse
|
|
6727
|
+
);
|
|
6438
6728
|
case 410:
|
|
6439
6729
|
throw new GoneError(
|
|
6440
6730
|
_response.error.body,
|
|
@@ -6547,23 +6837,35 @@ var ChatsClient = class {
|
|
|
6547
6837
|
if (_response.error.reason === "status-code") {
|
|
6548
6838
|
switch (_response.error.statusCode) {
|
|
6549
6839
|
case 400:
|
|
6550
|
-
throw new BadRequestError(
|
|
6840
|
+
throw new BadRequestError(
|
|
6841
|
+
_response.error.body,
|
|
6842
|
+
_response.rawResponse
|
|
6843
|
+
);
|
|
6551
6844
|
case 401:
|
|
6552
|
-
throw new UnauthorizedError(
|
|
6845
|
+
throw new UnauthorizedError(
|
|
6846
|
+
_response.error.body,
|
|
6847
|
+
_response.rawResponse
|
|
6848
|
+
);
|
|
6553
6849
|
case 402:
|
|
6554
6850
|
throw new PaymentRequiredError(
|
|
6555
6851
|
_response.error.body,
|
|
6556
6852
|
_response.rawResponse
|
|
6557
6853
|
);
|
|
6558
6854
|
case 403:
|
|
6559
|
-
throw new ForbiddenError(
|
|
6855
|
+
throw new ForbiddenError(
|
|
6856
|
+
_response.error.body,
|
|
6857
|
+
_response.rawResponse
|
|
6858
|
+
);
|
|
6560
6859
|
case 404:
|
|
6561
6860
|
throw new NotFoundError(
|
|
6562
6861
|
_response.error.body,
|
|
6563
6862
|
_response.rawResponse
|
|
6564
6863
|
);
|
|
6565
6864
|
case 409:
|
|
6566
|
-
throw new ConflictError(
|
|
6865
|
+
throw new ConflictError(
|
|
6866
|
+
_response.error.body,
|
|
6867
|
+
_response.rawResponse
|
|
6868
|
+
);
|
|
6567
6869
|
case 410:
|
|
6568
6870
|
throw new GoneError(
|
|
6569
6871
|
_response.error.body,
|
|
@@ -6671,23 +6973,35 @@ var ChatsClient = class {
|
|
|
6671
6973
|
if (_response.error.reason === "status-code") {
|
|
6672
6974
|
switch (_response.error.statusCode) {
|
|
6673
6975
|
case 400:
|
|
6674
|
-
throw new BadRequestError(
|
|
6976
|
+
throw new BadRequestError(
|
|
6977
|
+
_response.error.body,
|
|
6978
|
+
_response.rawResponse
|
|
6979
|
+
);
|
|
6675
6980
|
case 401:
|
|
6676
|
-
throw new UnauthorizedError(
|
|
6981
|
+
throw new UnauthorizedError(
|
|
6982
|
+
_response.error.body,
|
|
6983
|
+
_response.rawResponse
|
|
6984
|
+
);
|
|
6677
6985
|
case 402:
|
|
6678
6986
|
throw new PaymentRequiredError(
|
|
6679
6987
|
_response.error.body,
|
|
6680
6988
|
_response.rawResponse
|
|
6681
6989
|
);
|
|
6682
6990
|
case 403:
|
|
6683
|
-
throw new ForbiddenError(
|
|
6991
|
+
throw new ForbiddenError(
|
|
6992
|
+
_response.error.body,
|
|
6993
|
+
_response.rawResponse
|
|
6994
|
+
);
|
|
6684
6995
|
case 404:
|
|
6685
6996
|
throw new NotFoundError(
|
|
6686
6997
|
_response.error.body,
|
|
6687
6998
|
_response.rawResponse
|
|
6688
6999
|
);
|
|
6689
7000
|
case 409:
|
|
6690
|
-
throw new ConflictError(
|
|
7001
|
+
throw new ConflictError(
|
|
7002
|
+
_response.error.body,
|
|
7003
|
+
_response.rawResponse
|
|
7004
|
+
);
|
|
6691
7005
|
case 410:
|
|
6692
7006
|
throw new GoneError(
|
|
6693
7007
|
_response.error.body,
|
|
@@ -6797,23 +7111,35 @@ var ChatsClient = class {
|
|
|
6797
7111
|
if (_response.error.reason === "status-code") {
|
|
6798
7112
|
switch (_response.error.statusCode) {
|
|
6799
7113
|
case 400:
|
|
6800
|
-
throw new BadRequestError(
|
|
7114
|
+
throw new BadRequestError(
|
|
7115
|
+
_response.error.body,
|
|
7116
|
+
_response.rawResponse
|
|
7117
|
+
);
|
|
6801
7118
|
case 401:
|
|
6802
|
-
throw new UnauthorizedError(
|
|
7119
|
+
throw new UnauthorizedError(
|
|
7120
|
+
_response.error.body,
|
|
7121
|
+
_response.rawResponse
|
|
7122
|
+
);
|
|
6803
7123
|
case 402:
|
|
6804
7124
|
throw new PaymentRequiredError(
|
|
6805
7125
|
_response.error.body,
|
|
6806
7126
|
_response.rawResponse
|
|
6807
7127
|
);
|
|
6808
7128
|
case 403:
|
|
6809
|
-
throw new ForbiddenError(
|
|
7129
|
+
throw new ForbiddenError(
|
|
7130
|
+
_response.error.body,
|
|
7131
|
+
_response.rawResponse
|
|
7132
|
+
);
|
|
6810
7133
|
case 404:
|
|
6811
7134
|
throw new NotFoundError(
|
|
6812
7135
|
_response.error.body,
|
|
6813
7136
|
_response.rawResponse
|
|
6814
7137
|
);
|
|
6815
7138
|
case 409:
|
|
6816
|
-
throw new ConflictError(
|
|
7139
|
+
throw new ConflictError(
|
|
7140
|
+
_response.error.body,
|
|
7141
|
+
_response.rawResponse
|
|
7142
|
+
);
|
|
6817
7143
|
case 410:
|
|
6818
7144
|
throw new GoneError(
|
|
6819
7145
|
_response.error.body,
|
|
@@ -7066,23 +7392,35 @@ var ChatsClient = class {
|
|
|
7066
7392
|
if (_response.error.reason === "status-code") {
|
|
7067
7393
|
switch (_response.error.statusCode) {
|
|
7068
7394
|
case 400:
|
|
7069
|
-
throw new BadRequestError(
|
|
7395
|
+
throw new BadRequestError(
|
|
7396
|
+
_response.error.body,
|
|
7397
|
+
_response.rawResponse
|
|
7398
|
+
);
|
|
7070
7399
|
case 401:
|
|
7071
|
-
throw new UnauthorizedError(
|
|
7400
|
+
throw new UnauthorizedError(
|
|
7401
|
+
_response.error.body,
|
|
7402
|
+
_response.rawResponse
|
|
7403
|
+
);
|
|
7072
7404
|
case 402:
|
|
7073
7405
|
throw new PaymentRequiredError(
|
|
7074
7406
|
_response.error.body,
|
|
7075
7407
|
_response.rawResponse
|
|
7076
7408
|
);
|
|
7077
7409
|
case 403:
|
|
7078
|
-
throw new ForbiddenError(
|
|
7410
|
+
throw new ForbiddenError(
|
|
7411
|
+
_response.error.body,
|
|
7412
|
+
_response.rawResponse
|
|
7413
|
+
);
|
|
7079
7414
|
case 404:
|
|
7080
7415
|
throw new NotFoundError(
|
|
7081
7416
|
_response.error.body,
|
|
7082
7417
|
_response.rawResponse
|
|
7083
7418
|
);
|
|
7084
7419
|
case 409:
|
|
7085
|
-
throw new ConflictError(
|
|
7420
|
+
throw new ConflictError(
|
|
7421
|
+
_response.error.body,
|
|
7422
|
+
_response.rawResponse
|
|
7423
|
+
);
|
|
7086
7424
|
case 410:
|
|
7087
7425
|
throw new GoneError(
|
|
7088
7426
|
_response.error.body,
|
|
@@ -7185,23 +7523,35 @@ var ChatsClient = class {
|
|
|
7185
7523
|
if (_response.error.reason === "status-code") {
|
|
7186
7524
|
switch (_response.error.statusCode) {
|
|
7187
7525
|
case 400:
|
|
7188
|
-
throw new BadRequestError(
|
|
7526
|
+
throw new BadRequestError(
|
|
7527
|
+
_response.error.body,
|
|
7528
|
+
_response.rawResponse
|
|
7529
|
+
);
|
|
7189
7530
|
case 401:
|
|
7190
|
-
throw new UnauthorizedError(
|
|
7531
|
+
throw new UnauthorizedError(
|
|
7532
|
+
_response.error.body,
|
|
7533
|
+
_response.rawResponse
|
|
7534
|
+
);
|
|
7191
7535
|
case 402:
|
|
7192
7536
|
throw new PaymentRequiredError(
|
|
7193
7537
|
_response.error.body,
|
|
7194
7538
|
_response.rawResponse
|
|
7195
7539
|
);
|
|
7196
7540
|
case 403:
|
|
7197
|
-
throw new ForbiddenError(
|
|
7541
|
+
throw new ForbiddenError(
|
|
7542
|
+
_response.error.body,
|
|
7543
|
+
_response.rawResponse
|
|
7544
|
+
);
|
|
7198
7545
|
case 404:
|
|
7199
7546
|
throw new NotFoundError(
|
|
7200
7547
|
_response.error.body,
|
|
7201
7548
|
_response.rawResponse
|
|
7202
7549
|
);
|
|
7203
7550
|
case 409:
|
|
7204
|
-
throw new ConflictError(
|
|
7551
|
+
throw new ConflictError(
|
|
7552
|
+
_response.error.body,
|
|
7553
|
+
_response.rawResponse
|
|
7554
|
+
);
|
|
7205
7555
|
case 410:
|
|
7206
7556
|
throw new GoneError(
|
|
7207
7557
|
_response.error.body,
|
|
@@ -7307,23 +7657,35 @@ var ChatsClient = class {
|
|
|
7307
7657
|
if (_response.error.reason === "status-code") {
|
|
7308
7658
|
switch (_response.error.statusCode) {
|
|
7309
7659
|
case 400:
|
|
7310
|
-
throw new BadRequestError(
|
|
7660
|
+
throw new BadRequestError(
|
|
7661
|
+
_response.error.body,
|
|
7662
|
+
_response.rawResponse
|
|
7663
|
+
);
|
|
7311
7664
|
case 401:
|
|
7312
|
-
throw new UnauthorizedError(
|
|
7665
|
+
throw new UnauthorizedError(
|
|
7666
|
+
_response.error.body,
|
|
7667
|
+
_response.rawResponse
|
|
7668
|
+
);
|
|
7313
7669
|
case 402:
|
|
7314
7670
|
throw new PaymentRequiredError(
|
|
7315
7671
|
_response.error.body,
|
|
7316
7672
|
_response.rawResponse
|
|
7317
7673
|
);
|
|
7318
7674
|
case 403:
|
|
7319
|
-
throw new ForbiddenError(
|
|
7675
|
+
throw new ForbiddenError(
|
|
7676
|
+
_response.error.body,
|
|
7677
|
+
_response.rawResponse
|
|
7678
|
+
);
|
|
7320
7679
|
case 404:
|
|
7321
7680
|
throw new NotFoundError(
|
|
7322
7681
|
_response.error.body,
|
|
7323
7682
|
_response.rawResponse
|
|
7324
7683
|
);
|
|
7325
7684
|
case 409:
|
|
7326
|
-
throw new ConflictError(
|
|
7685
|
+
throw new ConflictError(
|
|
7686
|
+
_response.error.body,
|
|
7687
|
+
_response.rawResponse
|
|
7688
|
+
);
|
|
7327
7689
|
case 410:
|
|
7328
7690
|
throw new GoneError(
|
|
7329
7691
|
_response.error.body,
|
|
@@ -7426,23 +7788,35 @@ var ChatsClient = class {
|
|
|
7426
7788
|
if (_response.error.reason === "status-code") {
|
|
7427
7789
|
switch (_response.error.statusCode) {
|
|
7428
7790
|
case 400:
|
|
7429
|
-
throw new BadRequestError(
|
|
7791
|
+
throw new BadRequestError(
|
|
7792
|
+
_response.error.body,
|
|
7793
|
+
_response.rawResponse
|
|
7794
|
+
);
|
|
7430
7795
|
case 401:
|
|
7431
|
-
throw new UnauthorizedError(
|
|
7796
|
+
throw new UnauthorizedError(
|
|
7797
|
+
_response.error.body,
|
|
7798
|
+
_response.rawResponse
|
|
7799
|
+
);
|
|
7432
7800
|
case 402:
|
|
7433
7801
|
throw new PaymentRequiredError(
|
|
7434
7802
|
_response.error.body,
|
|
7435
7803
|
_response.rawResponse
|
|
7436
7804
|
);
|
|
7437
7805
|
case 403:
|
|
7438
|
-
throw new ForbiddenError(
|
|
7806
|
+
throw new ForbiddenError(
|
|
7807
|
+
_response.error.body,
|
|
7808
|
+
_response.rawResponse
|
|
7809
|
+
);
|
|
7439
7810
|
case 404:
|
|
7440
7811
|
throw new NotFoundError(
|
|
7441
7812
|
_response.error.body,
|
|
7442
7813
|
_response.rawResponse
|
|
7443
7814
|
);
|
|
7444
7815
|
case 409:
|
|
7445
|
-
throw new ConflictError(
|
|
7816
|
+
throw new ConflictError(
|
|
7817
|
+
_response.error.body,
|
|
7818
|
+
_response.rawResponse
|
|
7819
|
+
);
|
|
7446
7820
|
case 410:
|
|
7447
7821
|
throw new GoneError(
|
|
7448
7822
|
_response.error.body,
|
|
@@ -7548,23 +7922,35 @@ var ChatsClient = class {
|
|
|
7548
7922
|
if (_response.error.reason === "status-code") {
|
|
7549
7923
|
switch (_response.error.statusCode) {
|
|
7550
7924
|
case 400:
|
|
7551
|
-
throw new BadRequestError(
|
|
7925
|
+
throw new BadRequestError(
|
|
7926
|
+
_response.error.body,
|
|
7927
|
+
_response.rawResponse
|
|
7928
|
+
);
|
|
7552
7929
|
case 401:
|
|
7553
|
-
throw new UnauthorizedError(
|
|
7930
|
+
throw new UnauthorizedError(
|
|
7931
|
+
_response.error.body,
|
|
7932
|
+
_response.rawResponse
|
|
7933
|
+
);
|
|
7554
7934
|
case 402:
|
|
7555
7935
|
throw new PaymentRequiredError(
|
|
7556
7936
|
_response.error.body,
|
|
7557
7937
|
_response.rawResponse
|
|
7558
7938
|
);
|
|
7559
7939
|
case 403:
|
|
7560
|
-
throw new ForbiddenError(
|
|
7940
|
+
throw new ForbiddenError(
|
|
7941
|
+
_response.error.body,
|
|
7942
|
+
_response.rawResponse
|
|
7943
|
+
);
|
|
7561
7944
|
case 404:
|
|
7562
7945
|
throw new NotFoundError(
|
|
7563
7946
|
_response.error.body,
|
|
7564
7947
|
_response.rawResponse
|
|
7565
7948
|
);
|
|
7566
7949
|
case 409:
|
|
7567
|
-
throw new ConflictError(
|
|
7950
|
+
throw new ConflictError(
|
|
7951
|
+
_response.error.body,
|
|
7952
|
+
_response.rawResponse
|
|
7953
|
+
);
|
|
7568
7954
|
case 410:
|
|
7569
7955
|
throw new GoneError(
|
|
7570
7956
|
_response.error.body,
|
|
@@ -7671,23 +8057,35 @@ var ChatsClient = class {
|
|
|
7671
8057
|
if (_response.error.reason === "status-code") {
|
|
7672
8058
|
switch (_response.error.statusCode) {
|
|
7673
8059
|
case 400:
|
|
7674
|
-
throw new BadRequestError(
|
|
8060
|
+
throw new BadRequestError(
|
|
8061
|
+
_response.error.body,
|
|
8062
|
+
_response.rawResponse
|
|
8063
|
+
);
|
|
7675
8064
|
case 401:
|
|
7676
|
-
throw new UnauthorizedError(
|
|
8065
|
+
throw new UnauthorizedError(
|
|
8066
|
+
_response.error.body,
|
|
8067
|
+
_response.rawResponse
|
|
8068
|
+
);
|
|
7677
8069
|
case 402:
|
|
7678
8070
|
throw new PaymentRequiredError(
|
|
7679
8071
|
_response.error.body,
|
|
7680
8072
|
_response.rawResponse
|
|
7681
8073
|
);
|
|
7682
8074
|
case 403:
|
|
7683
|
-
throw new ForbiddenError(
|
|
8075
|
+
throw new ForbiddenError(
|
|
8076
|
+
_response.error.body,
|
|
8077
|
+
_response.rawResponse
|
|
8078
|
+
);
|
|
7684
8079
|
case 404:
|
|
7685
8080
|
throw new NotFoundError(
|
|
7686
8081
|
_response.error.body,
|
|
7687
8082
|
_response.rawResponse
|
|
7688
8083
|
);
|
|
7689
8084
|
case 409:
|
|
7690
|
-
throw new ConflictError(
|
|
8085
|
+
throw new ConflictError(
|
|
8086
|
+
_response.error.body,
|
|
8087
|
+
_response.rawResponse
|
|
8088
|
+
);
|
|
7691
8089
|
case 410:
|
|
7692
8090
|
throw new GoneError(
|
|
7693
8091
|
_response.error.body,
|
|
@@ -7801,23 +8199,35 @@ var ChatsClient = class {
|
|
|
7801
8199
|
if (_response.error.reason === "status-code") {
|
|
7802
8200
|
switch (_response.error.statusCode) {
|
|
7803
8201
|
case 400:
|
|
7804
|
-
throw new BadRequestError(
|
|
8202
|
+
throw new BadRequestError(
|
|
8203
|
+
_response.error.body,
|
|
8204
|
+
_response.rawResponse
|
|
8205
|
+
);
|
|
7805
8206
|
case 401:
|
|
7806
|
-
throw new UnauthorizedError(
|
|
8207
|
+
throw new UnauthorizedError(
|
|
8208
|
+
_response.error.body,
|
|
8209
|
+
_response.rawResponse
|
|
8210
|
+
);
|
|
7807
8211
|
case 402:
|
|
7808
8212
|
throw new PaymentRequiredError(
|
|
7809
8213
|
_response.error.body,
|
|
7810
8214
|
_response.rawResponse
|
|
7811
8215
|
);
|
|
7812
8216
|
case 403:
|
|
7813
|
-
throw new ForbiddenError(
|
|
8217
|
+
throw new ForbiddenError(
|
|
8218
|
+
_response.error.body,
|
|
8219
|
+
_response.rawResponse
|
|
8220
|
+
);
|
|
7814
8221
|
case 404:
|
|
7815
8222
|
throw new NotFoundError(
|
|
7816
8223
|
_response.error.body,
|
|
7817
8224
|
_response.rawResponse
|
|
7818
8225
|
);
|
|
7819
8226
|
case 409:
|
|
7820
|
-
throw new ConflictError(
|
|
8227
|
+
throw new ConflictError(
|
|
8228
|
+
_response.error.body,
|
|
8229
|
+
_response.rawResponse
|
|
8230
|
+
);
|
|
7821
8231
|
case 410:
|
|
7822
8232
|
throw new GoneError(
|
|
7823
8233
|
_response.error.body,
|
|
@@ -7925,23 +8335,35 @@ var ChatsClient = class {
|
|
|
7925
8335
|
if (_response.error.reason === "status-code") {
|
|
7926
8336
|
switch (_response.error.statusCode) {
|
|
7927
8337
|
case 400:
|
|
7928
|
-
throw new BadRequestError(
|
|
8338
|
+
throw new BadRequestError(
|
|
8339
|
+
_response.error.body,
|
|
8340
|
+
_response.rawResponse
|
|
8341
|
+
);
|
|
7929
8342
|
case 401:
|
|
7930
|
-
throw new UnauthorizedError(
|
|
8343
|
+
throw new UnauthorizedError(
|
|
8344
|
+
_response.error.body,
|
|
8345
|
+
_response.rawResponse
|
|
8346
|
+
);
|
|
7931
8347
|
case 402:
|
|
7932
8348
|
throw new PaymentRequiredError(
|
|
7933
8349
|
_response.error.body,
|
|
7934
8350
|
_response.rawResponse
|
|
7935
8351
|
);
|
|
7936
8352
|
case 403:
|
|
7937
|
-
throw new ForbiddenError(
|
|
8353
|
+
throw new ForbiddenError(
|
|
8354
|
+
_response.error.body,
|
|
8355
|
+
_response.rawResponse
|
|
8356
|
+
);
|
|
7938
8357
|
case 404:
|
|
7939
8358
|
throw new NotFoundError(
|
|
7940
8359
|
_response.error.body,
|
|
7941
8360
|
_response.rawResponse
|
|
7942
8361
|
);
|
|
7943
8362
|
case 409:
|
|
7944
|
-
throw new ConflictError(
|
|
8363
|
+
throw new ConflictError(
|
|
8364
|
+
_response.error.body,
|
|
8365
|
+
_response.rawResponse
|
|
8366
|
+
);
|
|
7945
8367
|
case 410:
|
|
7946
8368
|
throw new GoneError(
|
|
7947
8369
|
_response.error.body,
|
|
@@ -8062,23 +8484,35 @@ var FilesClient = class {
|
|
|
8062
8484
|
if (_response.error.reason === "status-code") {
|
|
8063
8485
|
switch (_response.error.statusCode) {
|
|
8064
8486
|
case 400:
|
|
8065
|
-
throw new BadRequestError(
|
|
8487
|
+
throw new BadRequestError(
|
|
8488
|
+
_response.error.body,
|
|
8489
|
+
_response.rawResponse
|
|
8490
|
+
);
|
|
8066
8491
|
case 401:
|
|
8067
|
-
throw new UnauthorizedError(
|
|
8492
|
+
throw new UnauthorizedError(
|
|
8493
|
+
_response.error.body,
|
|
8494
|
+
_response.rawResponse
|
|
8495
|
+
);
|
|
8068
8496
|
case 402:
|
|
8069
8497
|
throw new PaymentRequiredError(
|
|
8070
8498
|
_response.error.body,
|
|
8071
8499
|
_response.rawResponse
|
|
8072
8500
|
);
|
|
8073
8501
|
case 403:
|
|
8074
|
-
throw new ForbiddenError(
|
|
8502
|
+
throw new ForbiddenError(
|
|
8503
|
+
_response.error.body,
|
|
8504
|
+
_response.rawResponse
|
|
8505
|
+
);
|
|
8075
8506
|
case 404:
|
|
8076
8507
|
throw new NotFoundError(
|
|
8077
8508
|
_response.error.body,
|
|
8078
8509
|
_response.rawResponse
|
|
8079
8510
|
);
|
|
8080
8511
|
case 409:
|
|
8081
|
-
throw new ConflictError(
|
|
8512
|
+
throw new ConflictError(
|
|
8513
|
+
_response.error.body,
|
|
8514
|
+
_response.rawResponse
|
|
8515
|
+
);
|
|
8082
8516
|
case 410:
|
|
8083
8517
|
throw new GoneError(
|
|
8084
8518
|
_response.error.body,
|
|
@@ -8200,23 +8634,35 @@ var FilesClient = class {
|
|
|
8200
8634
|
if (_response.error.reason === "status-code") {
|
|
8201
8635
|
switch (_response.error.statusCode) {
|
|
8202
8636
|
case 400:
|
|
8203
|
-
throw new BadRequestError(
|
|
8637
|
+
throw new BadRequestError(
|
|
8638
|
+
_response.error.body,
|
|
8639
|
+
_response.rawResponse
|
|
8640
|
+
);
|
|
8204
8641
|
case 401:
|
|
8205
|
-
throw new UnauthorizedError(
|
|
8642
|
+
throw new UnauthorizedError(
|
|
8643
|
+
_response.error.body,
|
|
8644
|
+
_response.rawResponse
|
|
8645
|
+
);
|
|
8206
8646
|
case 402:
|
|
8207
8647
|
throw new PaymentRequiredError(
|
|
8208
8648
|
_response.error.body,
|
|
8209
8649
|
_response.rawResponse
|
|
8210
8650
|
);
|
|
8211
8651
|
case 403:
|
|
8212
|
-
throw new ForbiddenError(
|
|
8652
|
+
throw new ForbiddenError(
|
|
8653
|
+
_response.error.body,
|
|
8654
|
+
_response.rawResponse
|
|
8655
|
+
);
|
|
8213
8656
|
case 404:
|
|
8214
8657
|
throw new NotFoundError(
|
|
8215
8658
|
_response.error.body,
|
|
8216
8659
|
_response.rawResponse
|
|
8217
8660
|
);
|
|
8218
8661
|
case 409:
|
|
8219
|
-
throw new ConflictError(
|
|
8662
|
+
throw new ConflictError(
|
|
8663
|
+
_response.error.body,
|
|
8664
|
+
_response.rawResponse
|
|
8665
|
+
);
|
|
8220
8666
|
case 410:
|
|
8221
8667
|
throw new GoneError(
|
|
8222
8668
|
_response.error.body,
|
|
@@ -8318,23 +8764,35 @@ var FilesClient = class {
|
|
|
8318
8764
|
if (_response.error.reason === "status-code") {
|
|
8319
8765
|
switch (_response.error.statusCode) {
|
|
8320
8766
|
case 400:
|
|
8321
|
-
throw new BadRequestError(
|
|
8767
|
+
throw new BadRequestError(
|
|
8768
|
+
_response.error.body,
|
|
8769
|
+
_response.rawResponse
|
|
8770
|
+
);
|
|
8322
8771
|
case 401:
|
|
8323
|
-
throw new UnauthorizedError(
|
|
8772
|
+
throw new UnauthorizedError(
|
|
8773
|
+
_response.error.body,
|
|
8774
|
+
_response.rawResponse
|
|
8775
|
+
);
|
|
8324
8776
|
case 402:
|
|
8325
8777
|
throw new PaymentRequiredError(
|
|
8326
8778
|
_response.error.body,
|
|
8327
8779
|
_response.rawResponse
|
|
8328
8780
|
);
|
|
8329
8781
|
case 403:
|
|
8330
|
-
throw new ForbiddenError(
|
|
8782
|
+
throw new ForbiddenError(
|
|
8783
|
+
_response.error.body,
|
|
8784
|
+
_response.rawResponse
|
|
8785
|
+
);
|
|
8331
8786
|
case 404:
|
|
8332
8787
|
throw new NotFoundError(
|
|
8333
8788
|
_response.error.body,
|
|
8334
8789
|
_response.rawResponse
|
|
8335
8790
|
);
|
|
8336
8791
|
case 409:
|
|
8337
|
-
throw new ConflictError(
|
|
8792
|
+
throw new ConflictError(
|
|
8793
|
+
_response.error.body,
|
|
8794
|
+
_response.rawResponse
|
|
8795
|
+
);
|
|
8338
8796
|
case 410:
|
|
8339
8797
|
throw new GoneError(
|
|
8340
8798
|
_response.error.body,
|
|
@@ -8436,23 +8894,35 @@ var FilesClient = class {
|
|
|
8436
8894
|
if (_response.error.reason === "status-code") {
|
|
8437
8895
|
switch (_response.error.statusCode) {
|
|
8438
8896
|
case 400:
|
|
8439
|
-
throw new BadRequestError(
|
|
8897
|
+
throw new BadRequestError(
|
|
8898
|
+
_response.error.body,
|
|
8899
|
+
_response.rawResponse
|
|
8900
|
+
);
|
|
8440
8901
|
case 401:
|
|
8441
|
-
throw new UnauthorizedError(
|
|
8902
|
+
throw new UnauthorizedError(
|
|
8903
|
+
_response.error.body,
|
|
8904
|
+
_response.rawResponse
|
|
8905
|
+
);
|
|
8442
8906
|
case 402:
|
|
8443
8907
|
throw new PaymentRequiredError(
|
|
8444
8908
|
_response.error.body,
|
|
8445
8909
|
_response.rawResponse
|
|
8446
8910
|
);
|
|
8447
8911
|
case 403:
|
|
8448
|
-
throw new ForbiddenError(
|
|
8912
|
+
throw new ForbiddenError(
|
|
8913
|
+
_response.error.body,
|
|
8914
|
+
_response.rawResponse
|
|
8915
|
+
);
|
|
8449
8916
|
case 404:
|
|
8450
8917
|
throw new NotFoundError(
|
|
8451
8918
|
_response.error.body,
|
|
8452
8919
|
_response.rawResponse
|
|
8453
8920
|
);
|
|
8454
8921
|
case 409:
|
|
8455
|
-
throw new ConflictError(
|
|
8922
|
+
throw new ConflictError(
|
|
8923
|
+
_response.error.body,
|
|
8924
|
+
_response.rawResponse
|
|
8925
|
+
);
|
|
8456
8926
|
case 410:
|
|
8457
8927
|
throw new GoneError(
|
|
8458
8928
|
_response.error.body,
|
|
@@ -8555,23 +9025,35 @@ var FilesClient = class {
|
|
|
8555
9025
|
if (_response.error.reason === "status-code") {
|
|
8556
9026
|
switch (_response.error.statusCode) {
|
|
8557
9027
|
case 400:
|
|
8558
|
-
throw new BadRequestError(
|
|
9028
|
+
throw new BadRequestError(
|
|
9029
|
+
_response.error.body,
|
|
9030
|
+
_response.rawResponse
|
|
9031
|
+
);
|
|
8559
9032
|
case 401:
|
|
8560
|
-
throw new UnauthorizedError(
|
|
9033
|
+
throw new UnauthorizedError(
|
|
9034
|
+
_response.error.body,
|
|
9035
|
+
_response.rawResponse
|
|
9036
|
+
);
|
|
8561
9037
|
case 402:
|
|
8562
9038
|
throw new PaymentRequiredError(
|
|
8563
9039
|
_response.error.body,
|
|
8564
9040
|
_response.rawResponse
|
|
8565
9041
|
);
|
|
8566
9042
|
case 403:
|
|
8567
|
-
throw new ForbiddenError(
|
|
9043
|
+
throw new ForbiddenError(
|
|
9044
|
+
_response.error.body,
|
|
9045
|
+
_response.rawResponse
|
|
9046
|
+
);
|
|
8568
9047
|
case 404:
|
|
8569
9048
|
throw new NotFoundError(
|
|
8570
9049
|
_response.error.body,
|
|
8571
9050
|
_response.rawResponse
|
|
8572
9051
|
);
|
|
8573
9052
|
case 409:
|
|
8574
|
-
throw new ConflictError(
|
|
9053
|
+
throw new ConflictError(
|
|
9054
|
+
_response.error.body,
|
|
9055
|
+
_response.rawResponse
|
|
9056
|
+
);
|
|
8575
9057
|
case 410:
|
|
8576
9058
|
throw new GoneError(
|
|
8577
9059
|
_response.error.body,
|
|
@@ -8673,23 +9155,35 @@ var FilesClient = class {
|
|
|
8673
9155
|
if (_response.error.reason === "status-code") {
|
|
8674
9156
|
switch (_response.error.statusCode) {
|
|
8675
9157
|
case 400:
|
|
8676
|
-
throw new BadRequestError(
|
|
9158
|
+
throw new BadRequestError(
|
|
9159
|
+
_response.error.body,
|
|
9160
|
+
_response.rawResponse
|
|
9161
|
+
);
|
|
8677
9162
|
case 401:
|
|
8678
|
-
throw new UnauthorizedError(
|
|
9163
|
+
throw new UnauthorizedError(
|
|
9164
|
+
_response.error.body,
|
|
9165
|
+
_response.rawResponse
|
|
9166
|
+
);
|
|
8679
9167
|
case 402:
|
|
8680
9168
|
throw new PaymentRequiredError(
|
|
8681
9169
|
_response.error.body,
|
|
8682
9170
|
_response.rawResponse
|
|
8683
9171
|
);
|
|
8684
9172
|
case 403:
|
|
8685
|
-
throw new ForbiddenError(
|
|
9173
|
+
throw new ForbiddenError(
|
|
9174
|
+
_response.error.body,
|
|
9175
|
+
_response.rawResponse
|
|
9176
|
+
);
|
|
8686
9177
|
case 404:
|
|
8687
9178
|
throw new NotFoundError(
|
|
8688
9179
|
_response.error.body,
|
|
8689
9180
|
_response.rawResponse
|
|
8690
9181
|
);
|
|
8691
9182
|
case 409:
|
|
8692
|
-
throw new ConflictError(
|
|
9183
|
+
throw new ConflictError(
|
|
9184
|
+
_response.error.body,
|
|
9185
|
+
_response.rawResponse
|
|
9186
|
+
);
|
|
8693
9187
|
case 410:
|
|
8694
9188
|
throw new GoneError(
|
|
8695
9189
|
_response.error.body,
|
|
@@ -8795,23 +9289,35 @@ var IdentityClient = class {
|
|
|
8795
9289
|
if (_response.error.reason === "status-code") {
|
|
8796
9290
|
switch (_response.error.statusCode) {
|
|
8797
9291
|
case 400:
|
|
8798
|
-
throw new BadRequestError(
|
|
9292
|
+
throw new BadRequestError(
|
|
9293
|
+
_response.error.body,
|
|
9294
|
+
_response.rawResponse
|
|
9295
|
+
);
|
|
8799
9296
|
case 401:
|
|
8800
|
-
throw new UnauthorizedError(
|
|
9297
|
+
throw new UnauthorizedError(
|
|
9298
|
+
_response.error.body,
|
|
9299
|
+
_response.rawResponse
|
|
9300
|
+
);
|
|
8801
9301
|
case 402:
|
|
8802
9302
|
throw new PaymentRequiredError(
|
|
8803
9303
|
_response.error.body,
|
|
8804
9304
|
_response.rawResponse
|
|
8805
9305
|
);
|
|
8806
9306
|
case 403:
|
|
8807
|
-
throw new ForbiddenError(
|
|
9307
|
+
throw new ForbiddenError(
|
|
9308
|
+
_response.error.body,
|
|
9309
|
+
_response.rawResponse
|
|
9310
|
+
);
|
|
8808
9311
|
case 404:
|
|
8809
9312
|
throw new NotFoundError(
|
|
8810
9313
|
_response.error.body,
|
|
8811
9314
|
_response.rawResponse
|
|
8812
9315
|
);
|
|
8813
9316
|
case 409:
|
|
8814
|
-
throw new ConflictError(
|
|
9317
|
+
throw new ConflictError(
|
|
9318
|
+
_response.error.body,
|
|
9319
|
+
_response.rawResponse
|
|
9320
|
+
);
|
|
8815
9321
|
case 410:
|
|
8816
9322
|
throw new GoneError(
|
|
8817
9323
|
_response.error.body,
|
|
@@ -8903,23 +9409,35 @@ var IdentityClient = class {
|
|
|
8903
9409
|
if (_response.error.reason === "status-code") {
|
|
8904
9410
|
switch (_response.error.statusCode) {
|
|
8905
9411
|
case 400:
|
|
8906
|
-
throw new BadRequestError(
|
|
9412
|
+
throw new BadRequestError(
|
|
9413
|
+
_response.error.body,
|
|
9414
|
+
_response.rawResponse
|
|
9415
|
+
);
|
|
8907
9416
|
case 401:
|
|
8908
|
-
throw new UnauthorizedError(
|
|
9417
|
+
throw new UnauthorizedError(
|
|
9418
|
+
_response.error.body,
|
|
9419
|
+
_response.rawResponse
|
|
9420
|
+
);
|
|
8909
9421
|
case 402:
|
|
8910
9422
|
throw new PaymentRequiredError(
|
|
8911
9423
|
_response.error.body,
|
|
8912
9424
|
_response.rawResponse
|
|
8913
9425
|
);
|
|
8914
9426
|
case 403:
|
|
8915
|
-
throw new ForbiddenError(
|
|
9427
|
+
throw new ForbiddenError(
|
|
9428
|
+
_response.error.body,
|
|
9429
|
+
_response.rawResponse
|
|
9430
|
+
);
|
|
8916
9431
|
case 404:
|
|
8917
9432
|
throw new NotFoundError(
|
|
8918
9433
|
_response.error.body,
|
|
8919
9434
|
_response.rawResponse
|
|
8920
9435
|
);
|
|
8921
9436
|
case 409:
|
|
8922
|
-
throw new ConflictError(
|
|
9437
|
+
throw new ConflictError(
|
|
9438
|
+
_response.error.body,
|
|
9439
|
+
_response.rawResponse
|
|
9440
|
+
);
|
|
8923
9441
|
case 410:
|
|
8924
9442
|
throw new GoneError(
|
|
8925
9443
|
_response.error.body,
|
|
@@ -9197,23 +9715,35 @@ var MachinesClient = class {
|
|
|
9197
9715
|
if (_response.error.reason === "status-code") {
|
|
9198
9716
|
switch (_response.error.statusCode) {
|
|
9199
9717
|
case 400:
|
|
9200
|
-
throw new BadRequestError(
|
|
9718
|
+
throw new BadRequestError(
|
|
9719
|
+
_response.error.body,
|
|
9720
|
+
_response.rawResponse
|
|
9721
|
+
);
|
|
9201
9722
|
case 401:
|
|
9202
|
-
throw new UnauthorizedError(
|
|
9723
|
+
throw new UnauthorizedError(
|
|
9724
|
+
_response.error.body,
|
|
9725
|
+
_response.rawResponse
|
|
9726
|
+
);
|
|
9203
9727
|
case 402:
|
|
9204
9728
|
throw new PaymentRequiredError(
|
|
9205
9729
|
_response.error.body,
|
|
9206
9730
|
_response.rawResponse
|
|
9207
9731
|
);
|
|
9208
9732
|
case 403:
|
|
9209
|
-
throw new ForbiddenError(
|
|
9733
|
+
throw new ForbiddenError(
|
|
9734
|
+
_response.error.body,
|
|
9735
|
+
_response.rawResponse
|
|
9736
|
+
);
|
|
9210
9737
|
case 404:
|
|
9211
9738
|
throw new NotFoundError(
|
|
9212
9739
|
_response.error.body,
|
|
9213
9740
|
_response.rawResponse
|
|
9214
9741
|
);
|
|
9215
9742
|
case 409:
|
|
9216
|
-
throw new ConflictError(
|
|
9743
|
+
throw new ConflictError(
|
|
9744
|
+
_response.error.body,
|
|
9745
|
+
_response.rawResponse
|
|
9746
|
+
);
|
|
9217
9747
|
case 410:
|
|
9218
9748
|
throw new GoneError(
|
|
9219
9749
|
_response.error.body,
|
|
@@ -9315,23 +9845,35 @@ var MachinesClient = class {
|
|
|
9315
9845
|
if (_response.error.reason === "status-code") {
|
|
9316
9846
|
switch (_response.error.statusCode) {
|
|
9317
9847
|
case 400:
|
|
9318
|
-
throw new BadRequestError(
|
|
9848
|
+
throw new BadRequestError(
|
|
9849
|
+
_response.error.body,
|
|
9850
|
+
_response.rawResponse
|
|
9851
|
+
);
|
|
9319
9852
|
case 401:
|
|
9320
|
-
throw new UnauthorizedError(
|
|
9853
|
+
throw new UnauthorizedError(
|
|
9854
|
+
_response.error.body,
|
|
9855
|
+
_response.rawResponse
|
|
9856
|
+
);
|
|
9321
9857
|
case 402:
|
|
9322
9858
|
throw new PaymentRequiredError(
|
|
9323
9859
|
_response.error.body,
|
|
9324
9860
|
_response.rawResponse
|
|
9325
9861
|
);
|
|
9326
9862
|
case 403:
|
|
9327
|
-
throw new ForbiddenError(
|
|
9863
|
+
throw new ForbiddenError(
|
|
9864
|
+
_response.error.body,
|
|
9865
|
+
_response.rawResponse
|
|
9866
|
+
);
|
|
9328
9867
|
case 404:
|
|
9329
9868
|
throw new NotFoundError(
|
|
9330
9869
|
_response.error.body,
|
|
9331
9870
|
_response.rawResponse
|
|
9332
9871
|
);
|
|
9333
9872
|
case 409:
|
|
9334
|
-
throw new ConflictError(
|
|
9873
|
+
throw new ConflictError(
|
|
9874
|
+
_response.error.body,
|
|
9875
|
+
_response.rawResponse
|
|
9876
|
+
);
|
|
9335
9877
|
case 410:
|
|
9336
9878
|
throw new GoneError(
|
|
9337
9879
|
_response.error.body,
|
|
@@ -9433,23 +9975,35 @@ var MachinesClient = class {
|
|
|
9433
9975
|
if (_response.error.reason === "status-code") {
|
|
9434
9976
|
switch (_response.error.statusCode) {
|
|
9435
9977
|
case 400:
|
|
9436
|
-
throw new BadRequestError(
|
|
9978
|
+
throw new BadRequestError(
|
|
9979
|
+
_response.error.body,
|
|
9980
|
+
_response.rawResponse
|
|
9981
|
+
);
|
|
9437
9982
|
case 401:
|
|
9438
|
-
throw new UnauthorizedError(
|
|
9983
|
+
throw new UnauthorizedError(
|
|
9984
|
+
_response.error.body,
|
|
9985
|
+
_response.rawResponse
|
|
9986
|
+
);
|
|
9439
9987
|
case 402:
|
|
9440
9988
|
throw new PaymentRequiredError(
|
|
9441
9989
|
_response.error.body,
|
|
9442
9990
|
_response.rawResponse
|
|
9443
9991
|
);
|
|
9444
9992
|
case 403:
|
|
9445
|
-
throw new ForbiddenError(
|
|
9993
|
+
throw new ForbiddenError(
|
|
9994
|
+
_response.error.body,
|
|
9995
|
+
_response.rawResponse
|
|
9996
|
+
);
|
|
9446
9997
|
case 404:
|
|
9447
9998
|
throw new NotFoundError(
|
|
9448
9999
|
_response.error.body,
|
|
9449
10000
|
_response.rawResponse
|
|
9450
10001
|
);
|
|
9451
10002
|
case 409:
|
|
9452
|
-
throw new ConflictError(
|
|
10003
|
+
throw new ConflictError(
|
|
10004
|
+
_response.error.body,
|
|
10005
|
+
_response.rawResponse
|
|
10006
|
+
);
|
|
9453
10007
|
case 410:
|
|
9454
10008
|
throw new GoneError(
|
|
9455
10009
|
_response.error.body,
|
|
@@ -9553,23 +10107,35 @@ var MachinesClient = class {
|
|
|
9553
10107
|
if (_response.error.reason === "status-code") {
|
|
9554
10108
|
switch (_response.error.statusCode) {
|
|
9555
10109
|
case 400:
|
|
9556
|
-
throw new BadRequestError(
|
|
10110
|
+
throw new BadRequestError(
|
|
10111
|
+
_response.error.body,
|
|
10112
|
+
_response.rawResponse
|
|
10113
|
+
);
|
|
9557
10114
|
case 401:
|
|
9558
|
-
throw new UnauthorizedError(
|
|
10115
|
+
throw new UnauthorizedError(
|
|
10116
|
+
_response.error.body,
|
|
10117
|
+
_response.rawResponse
|
|
10118
|
+
);
|
|
9559
10119
|
case 402:
|
|
9560
10120
|
throw new PaymentRequiredError(
|
|
9561
10121
|
_response.error.body,
|
|
9562
10122
|
_response.rawResponse
|
|
9563
10123
|
);
|
|
9564
10124
|
case 403:
|
|
9565
|
-
throw new ForbiddenError(
|
|
10125
|
+
throw new ForbiddenError(
|
|
10126
|
+
_response.error.body,
|
|
10127
|
+
_response.rawResponse
|
|
10128
|
+
);
|
|
9566
10129
|
case 404:
|
|
9567
10130
|
throw new NotFoundError(
|
|
9568
10131
|
_response.error.body,
|
|
9569
10132
|
_response.rawResponse
|
|
9570
10133
|
);
|
|
9571
10134
|
case 409:
|
|
9572
|
-
throw new ConflictError(
|
|
10135
|
+
throw new ConflictError(
|
|
10136
|
+
_response.error.body,
|
|
10137
|
+
_response.rawResponse
|
|
10138
|
+
);
|
|
9573
10139
|
case 410:
|
|
9574
10140
|
throw new GoneError(
|
|
9575
10141
|
_response.error.body,
|
|
@@ -9681,23 +10247,35 @@ var ProvidersClient = class {
|
|
|
9681
10247
|
if (_response.error.reason === "status-code") {
|
|
9682
10248
|
switch (_response.error.statusCode) {
|
|
9683
10249
|
case 400:
|
|
9684
|
-
throw new BadRequestError(
|
|
10250
|
+
throw new BadRequestError(
|
|
10251
|
+
_response.error.body,
|
|
10252
|
+
_response.rawResponse
|
|
10253
|
+
);
|
|
9685
10254
|
case 401:
|
|
9686
|
-
throw new UnauthorizedError(
|
|
10255
|
+
throw new UnauthorizedError(
|
|
10256
|
+
_response.error.body,
|
|
10257
|
+
_response.rawResponse
|
|
10258
|
+
);
|
|
9687
10259
|
case 402:
|
|
9688
10260
|
throw new PaymentRequiredError(
|
|
9689
10261
|
_response.error.body,
|
|
9690
10262
|
_response.rawResponse
|
|
9691
10263
|
);
|
|
9692
10264
|
case 403:
|
|
9693
|
-
throw new ForbiddenError(
|
|
10265
|
+
throw new ForbiddenError(
|
|
10266
|
+
_response.error.body,
|
|
10267
|
+
_response.rawResponse
|
|
10268
|
+
);
|
|
9694
10269
|
case 404:
|
|
9695
10270
|
throw new NotFoundError(
|
|
9696
10271
|
_response.error.body,
|
|
9697
10272
|
_response.rawResponse
|
|
9698
10273
|
);
|
|
9699
10274
|
case 409:
|
|
9700
|
-
throw new ConflictError(
|
|
10275
|
+
throw new ConflictError(
|
|
10276
|
+
_response.error.body,
|
|
10277
|
+
_response.rawResponse
|
|
10278
|
+
);
|
|
9701
10279
|
case 410:
|
|
9702
10280
|
throw new GoneError(
|
|
9703
10281
|
_response.error.body,
|
|
@@ -9802,23 +10380,35 @@ var ProvidersClient = class {
|
|
|
9802
10380
|
if (_response.error.reason === "status-code") {
|
|
9803
10381
|
switch (_response.error.statusCode) {
|
|
9804
10382
|
case 400:
|
|
9805
|
-
throw new BadRequestError(
|
|
10383
|
+
throw new BadRequestError(
|
|
10384
|
+
_response.error.body,
|
|
10385
|
+
_response.rawResponse
|
|
10386
|
+
);
|
|
9806
10387
|
case 401:
|
|
9807
|
-
throw new UnauthorizedError(
|
|
10388
|
+
throw new UnauthorizedError(
|
|
10389
|
+
_response.error.body,
|
|
10390
|
+
_response.rawResponse
|
|
10391
|
+
);
|
|
9808
10392
|
case 402:
|
|
9809
10393
|
throw new PaymentRequiredError(
|
|
9810
10394
|
_response.error.body,
|
|
9811
10395
|
_response.rawResponse
|
|
9812
10396
|
);
|
|
9813
10397
|
case 403:
|
|
9814
|
-
throw new ForbiddenError(
|
|
10398
|
+
throw new ForbiddenError(
|
|
10399
|
+
_response.error.body,
|
|
10400
|
+
_response.rawResponse
|
|
10401
|
+
);
|
|
9815
10402
|
case 404:
|
|
9816
10403
|
throw new NotFoundError(
|
|
9817
10404
|
_response.error.body,
|
|
9818
10405
|
_response.rawResponse
|
|
9819
10406
|
);
|
|
9820
10407
|
case 409:
|
|
9821
|
-
throw new ConflictError(
|
|
10408
|
+
throw new ConflictError(
|
|
10409
|
+
_response.error.body,
|
|
10410
|
+
_response.rawResponse
|
|
10411
|
+
);
|
|
9822
10412
|
case 410:
|
|
9823
10413
|
throw new GoneError(
|
|
9824
10414
|
_response.error.body,
|
|
@@ -9937,23 +10527,35 @@ var ProvidersClient = class {
|
|
|
9937
10527
|
if (_response.error.reason === "status-code") {
|
|
9938
10528
|
switch (_response.error.statusCode) {
|
|
9939
10529
|
case 400:
|
|
9940
|
-
throw new BadRequestError(
|
|
10530
|
+
throw new BadRequestError(
|
|
10531
|
+
_response.error.body,
|
|
10532
|
+
_response.rawResponse
|
|
10533
|
+
);
|
|
9941
10534
|
case 401:
|
|
9942
|
-
throw new UnauthorizedError(
|
|
10535
|
+
throw new UnauthorizedError(
|
|
10536
|
+
_response.error.body,
|
|
10537
|
+
_response.rawResponse
|
|
10538
|
+
);
|
|
9943
10539
|
case 402:
|
|
9944
10540
|
throw new PaymentRequiredError(
|
|
9945
10541
|
_response.error.body,
|
|
9946
10542
|
_response.rawResponse
|
|
9947
10543
|
);
|
|
9948
10544
|
case 403:
|
|
9949
|
-
throw new ForbiddenError(
|
|
10545
|
+
throw new ForbiddenError(
|
|
10546
|
+
_response.error.body,
|
|
10547
|
+
_response.rawResponse
|
|
10548
|
+
);
|
|
9950
10549
|
case 404:
|
|
9951
10550
|
throw new NotFoundError(
|
|
9952
10551
|
_response.error.body,
|
|
9953
10552
|
_response.rawResponse
|
|
9954
10553
|
);
|
|
9955
10554
|
case 409:
|
|
9956
|
-
throw new ConflictError(
|
|
10555
|
+
throw new ConflictError(
|
|
10556
|
+
_response.error.body,
|
|
10557
|
+
_response.rawResponse
|
|
10558
|
+
);
|
|
9957
10559
|
case 410:
|
|
9958
10560
|
throw new GoneError(
|
|
9959
10561
|
_response.error.body,
|
|
@@ -10064,23 +10666,35 @@ var ProvidersClient = class {
|
|
|
10064
10666
|
if (_response.error.reason === "status-code") {
|
|
10065
10667
|
switch (_response.error.statusCode) {
|
|
10066
10668
|
case 400:
|
|
10067
|
-
throw new BadRequestError(
|
|
10669
|
+
throw new BadRequestError(
|
|
10670
|
+
_response.error.body,
|
|
10671
|
+
_response.rawResponse
|
|
10672
|
+
);
|
|
10068
10673
|
case 401:
|
|
10069
|
-
throw new UnauthorizedError(
|
|
10674
|
+
throw new UnauthorizedError(
|
|
10675
|
+
_response.error.body,
|
|
10676
|
+
_response.rawResponse
|
|
10677
|
+
);
|
|
10070
10678
|
case 402:
|
|
10071
10679
|
throw new PaymentRequiredError(
|
|
10072
10680
|
_response.error.body,
|
|
10073
10681
|
_response.rawResponse
|
|
10074
10682
|
);
|
|
10075
10683
|
case 403:
|
|
10076
|
-
throw new ForbiddenError(
|
|
10684
|
+
throw new ForbiddenError(
|
|
10685
|
+
_response.error.body,
|
|
10686
|
+
_response.rawResponse
|
|
10687
|
+
);
|
|
10077
10688
|
case 404:
|
|
10078
10689
|
throw new NotFoundError(
|
|
10079
10690
|
_response.error.body,
|
|
10080
10691
|
_response.rawResponse
|
|
10081
10692
|
);
|
|
10082
10693
|
case 409:
|
|
10083
|
-
throw new ConflictError(
|
|
10694
|
+
throw new ConflictError(
|
|
10695
|
+
_response.error.body,
|
|
10696
|
+
_response.rawResponse
|
|
10697
|
+
);
|
|
10084
10698
|
case 410:
|
|
10085
10699
|
throw new GoneError(
|
|
10086
10700
|
_response.error.body,
|
|
@@ -10188,23 +10802,35 @@ var ProvidersClient = class {
|
|
|
10188
10802
|
if (_response.error.reason === "status-code") {
|
|
10189
10803
|
switch (_response.error.statusCode) {
|
|
10190
10804
|
case 400:
|
|
10191
|
-
throw new BadRequestError(
|
|
10805
|
+
throw new BadRequestError(
|
|
10806
|
+
_response.error.body,
|
|
10807
|
+
_response.rawResponse
|
|
10808
|
+
);
|
|
10192
10809
|
case 401:
|
|
10193
|
-
throw new UnauthorizedError(
|
|
10810
|
+
throw new UnauthorizedError(
|
|
10811
|
+
_response.error.body,
|
|
10812
|
+
_response.rawResponse
|
|
10813
|
+
);
|
|
10194
10814
|
case 402:
|
|
10195
10815
|
throw new PaymentRequiredError(
|
|
10196
10816
|
_response.error.body,
|
|
10197
10817
|
_response.rawResponse
|
|
10198
10818
|
);
|
|
10199
10819
|
case 403:
|
|
10200
|
-
throw new ForbiddenError(
|
|
10820
|
+
throw new ForbiddenError(
|
|
10821
|
+
_response.error.body,
|
|
10822
|
+
_response.rawResponse
|
|
10823
|
+
);
|
|
10201
10824
|
case 404:
|
|
10202
10825
|
throw new NotFoundError(
|
|
10203
10826
|
_response.error.body,
|
|
10204
10827
|
_response.rawResponse
|
|
10205
10828
|
);
|
|
10206
10829
|
case 409:
|
|
10207
|
-
throw new ConflictError(
|
|
10830
|
+
throw new ConflictError(
|
|
10831
|
+
_response.error.body,
|
|
10832
|
+
_response.rawResponse
|
|
10833
|
+
);
|
|
10208
10834
|
case 410:
|
|
10209
10835
|
throw new GoneError(
|
|
10210
10836
|
_response.error.body,
|
|
@@ -10318,23 +10944,35 @@ var ProvidersClient = class {
|
|
|
10318
10944
|
if (_response.error.reason === "status-code") {
|
|
10319
10945
|
switch (_response.error.statusCode) {
|
|
10320
10946
|
case 400:
|
|
10321
|
-
throw new BadRequestError(
|
|
10947
|
+
throw new BadRequestError(
|
|
10948
|
+
_response.error.body,
|
|
10949
|
+
_response.rawResponse
|
|
10950
|
+
);
|
|
10322
10951
|
case 401:
|
|
10323
|
-
throw new UnauthorizedError(
|
|
10952
|
+
throw new UnauthorizedError(
|
|
10953
|
+
_response.error.body,
|
|
10954
|
+
_response.rawResponse
|
|
10955
|
+
);
|
|
10324
10956
|
case 402:
|
|
10325
10957
|
throw new PaymentRequiredError(
|
|
10326
10958
|
_response.error.body,
|
|
10327
10959
|
_response.rawResponse
|
|
10328
10960
|
);
|
|
10329
10961
|
case 403:
|
|
10330
|
-
throw new ForbiddenError(
|
|
10962
|
+
throw new ForbiddenError(
|
|
10963
|
+
_response.error.body,
|
|
10964
|
+
_response.rawResponse
|
|
10965
|
+
);
|
|
10331
10966
|
case 404:
|
|
10332
10967
|
throw new NotFoundError(
|
|
10333
10968
|
_response.error.body,
|
|
10334
10969
|
_response.rawResponse
|
|
10335
10970
|
);
|
|
10336
10971
|
case 409:
|
|
10337
|
-
throw new ConflictError(
|
|
10972
|
+
throw new ConflictError(
|
|
10973
|
+
_response.error.body,
|
|
10974
|
+
_response.rawResponse
|
|
10975
|
+
);
|
|
10338
10976
|
case 410:
|
|
10339
10977
|
throw new GoneError(
|
|
10340
10978
|
_response.error.body,
|
|
@@ -10439,23 +11077,35 @@ var ProvidersClient = class {
|
|
|
10439
11077
|
if (_response.error.reason === "status-code") {
|
|
10440
11078
|
switch (_response.error.statusCode) {
|
|
10441
11079
|
case 400:
|
|
10442
|
-
throw new BadRequestError(
|
|
11080
|
+
throw new BadRequestError(
|
|
11081
|
+
_response.error.body,
|
|
11082
|
+
_response.rawResponse
|
|
11083
|
+
);
|
|
10443
11084
|
case 401:
|
|
10444
|
-
throw new UnauthorizedError(
|
|
11085
|
+
throw new UnauthorizedError(
|
|
11086
|
+
_response.error.body,
|
|
11087
|
+
_response.rawResponse
|
|
11088
|
+
);
|
|
10445
11089
|
case 402:
|
|
10446
11090
|
throw new PaymentRequiredError(
|
|
10447
11091
|
_response.error.body,
|
|
10448
11092
|
_response.rawResponse
|
|
10449
11093
|
);
|
|
10450
11094
|
case 403:
|
|
10451
|
-
throw new ForbiddenError(
|
|
11095
|
+
throw new ForbiddenError(
|
|
11096
|
+
_response.error.body,
|
|
11097
|
+
_response.rawResponse
|
|
11098
|
+
);
|
|
10452
11099
|
case 404:
|
|
10453
11100
|
throw new NotFoundError(
|
|
10454
11101
|
_response.error.body,
|
|
10455
11102
|
_response.rawResponse
|
|
10456
11103
|
);
|
|
10457
11104
|
case 409:
|
|
10458
|
-
throw new ConflictError(
|
|
11105
|
+
throw new ConflictError(
|
|
11106
|
+
_response.error.body,
|
|
11107
|
+
_response.rawResponse
|
|
11108
|
+
);
|
|
10459
11109
|
case 410:
|
|
10460
11110
|
throw new GoneError(
|
|
10461
11111
|
_response.error.body,
|
|
@@ -14116,7 +14766,7 @@ function withExtra(gen, extra) {
|
|
|
14116
14766
|
}
|
|
14117
14767
|
|
|
14118
14768
|
// src/index.ts
|
|
14119
|
-
var DEFAULT_BASE_URL =
|
|
14769
|
+
var DEFAULT_BASE_URL = SmoothAgentApiEnvironment.Default.replace(/\/v3$/, "");
|
|
14120
14770
|
var SmoothAgent = class {
|
|
14121
14771
|
/** O cliente REST gerado (todas as rotas da audience `client`). */
|
|
14122
14772
|
api;
|
|
@@ -14198,4 +14848,4 @@ export {
|
|
|
14198
14848
|
DEFAULT_BASE_URL,
|
|
14199
14849
|
SmoothAgent
|
|
14200
14850
|
};
|
|
14201
|
-
//# sourceMappingURL=chunk-
|
|
14851
|
+
//# sourceMappingURL=chunk-E4ZFXITU.js.map
|